pyegeria 5.4.0.28__py3-none-any.whl → 5.5.3.3__py3-none-any.whl

pyegeria/{glossary_manager.py → omvs/glossary_manager.py}

@@ -1,63 +1,37 @@
 """
-PDX-License-Identifier: Apache-2.0
+SPDX-License-Identifier: Apache-2.0
 Copyright Contributors to the ODPi Egeria project.
 
-This module contains an initial version of the glossary_manager omvs module. There are additional methods that will be
-added in subsequent versions of the glossary_omvs module.
+This module contains an initial version of the glossary_manager module.
 
 """
 
 import asyncio
 import csv
 import os
-import time
-from typing import List, Annotated, Literal
+from typing import List, Annotated, Literal, Optional
 
 from loguru import logger
 from pydantic import Field
 
-from pyegeria._client_new import Client2
-from pyegeria._exceptions import InvalidParameterException
-from pyegeria._exceptions_new import PyegeriaInvalidParameterException
-from pyegeria._globals import NO_GUID_RETURNED
-from pyegeria._validators import validate_guid
-from pyegeria.collection_manager import CollectionManager
-from pyegeria.config import settings as app_settings
-from pyegeria.models import (NewElementRequestBody,
-                             ReferenceableProperties, UpdateElementRequestBody, DeleteRequestBody, TemplateRequestBody,
+from pyegeria.core._exceptions import PyegeriaInvalidParameterException
+from pyegeria.core._globals import NO_GUID_RETURNED
+from pyegeria.core._validators import validate_guid
+from pyegeria.omvs.collection_manager import CollectionManager
+from pyegeria.core.config import settings as app_settings
+from pyegeria.models import (NewElementRequestBody, DeleteElementRequestBody, DeleteRelationshipRequestBody,
+                             ReferenceableProperties, UpdateElementRequestBody, TemplateRequestBody,
                              NewRelationshipRequestBody, UpdateRelationshipRequestBody, NewClassificationRequestBody,
-                             FilterRequestBody, GetRequestBody, SearchStringRequestBody, UpdateStatusRequestBody)
-from pyegeria._output_formats import select_output_format_set, get_output_format_type_match
-from pyegeria.output_formatter import (generate_output,
-                                       _extract_referenceable_properties, populate_columns_from_properties,
-                                       get_required_relationships)
-from pyegeria.utils import body_slimmer, dynamic_catch
+                             FilterRequestBody, GetRequestBody, SearchStringRequestBody,
+                             DeleteClassificationRequestBody)
+from pyegeria.view.output_formatter import (generate_output,
+                                            _extract_referenceable_properties, populate_common_columns,
+                                            overlay_additional_values, resolve_output_formats)
+from pyegeria.core.utils import body_slimmer, dynamic_catch
 
 EGERIA_LOCAL_QUALIFIER = app_settings.User_Profile.egeria_local_qualifier
 
 
-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 GlossaryProperties(ReferenceableProperties):
     class_: Annotated[Literal["GlossaryProperties"], Field(alias="class")]
@@ -78,22 +52,21 @@ class GlossaryTermProperties(ReferenceableProperties):
 
 class GlossaryManager(CollectionManager):
     """
-    GlossaryManager is a class that extends the Client class. It provides methods to create and manage glossaries,
-    terms and categories.
-
-    Attributes:
-
-        view_server: str
-            The name of the View Server to connect to.
-        platform_url : str
-            URL of the server platform to connect to
-        user_id : str
-            The identity of the user calling the method - this sets a default optionally used by the methods
-            when the user doesn't pass the user_id on a method call.
-        user_pwd: str
-            The password associated with the user_id. Defaults to None
-
-
+    Client for the Glossary Manager View Service.
+
+    The Glossary Manager View Service provides methods to create and manage glossaries,
+    terms, and categories.
+
+    Attributes
+    ----------
+    view_server : str
+        The name of the View Server to connect to.
+    platform_url : str
+        URL of the server platform to connect to.
+    user_id : str
+        The identity of the user calling the method.
+    user_pwd : str
+        The password associated with the user_id. Defaults to None.
     """
 
     def __init__(
@@ -101,17 +74,20 @@ class GlossaryManager(CollectionManager):
             view_server: str,
             platform_url: str,
             user_id: str,
-            user_pwd: str = None,
-            token: str = None,
+            user_pwd: Optional[str] = None,
+            token: Optional[str] = None,
             ):
-        self.gl_mgr_command_root: str
         self.view_server = view_server
         self.platform_url = platform_url
         self.user_id = user_id
         self.user_pwd = user_pwd
+        self.url_marker = "glossary-manager"
 
-        CollectionManager.__init__(self, view_server, platform_url, user_id, user_pwd, token)
 
+        CollectionManager.__init__(self, view_server, platform_url, user_id, user_pwd, token)
+        # result = self.get_platform_origin()
+        # logger.info(f"GlossaryManager initialized, platform origin is: {result}")
+        self.glossary_command_root = f"{self.platform_url}/servers/{self.view_server}/api/open-metadata/glossary-manager"
     #
     #       Get Valid Values for Enumerations
     #
@@ -128,9 +104,35 @@ class GlossaryManager(CollectionManager):
 
 
     @dynamic_catch
-    async def _async_create_glossary(self, display_name: str, description: str = None, language: str = "English", usage: str = None,
-                        category: str = None, body: dict | NewElementRequestBody = None) -> str:
-        """Create a new glossary with optional classification. """
+    async def _async_create_glossary(self, display_name: str, description: Optional[str] = None, language: str = "English", usage: Optional[str] = None,
+                        category: Optional[str] = None, body: Optional[dict | NewElementRequestBody] = None) -> str:
+        """Create a new glossary. Async version.
+
+        Parameters
+        ----------
+        display_name : str
+            The name of the glossary.
+        description : str, optional
+            The description of the glossary.
+        language : str, optional
+            The language of the glossary (default is "English").
+        usage : str, optional
+            The usage information for the glossary.
+        category : str, optional
+            The category for the glossary.
+        body : dict | NewElementRequestBody, optional
+            If provided, the request body for creating the glossary.
+
+        Returns
+        -------
+        str
+            The GUID of the newly created glossary.
+
+        Raises
+        ------
+        PyegeriaException
+            If there are issues in communications, message format, or Egeria errors.
+        """
         if body is None:
             qualified_name = self.__create_qualified_name__("Glossary", display_name, EGERIA_LOCAL_QUALIFIER)
             body = {
@@ -149,17 +151,43 @@ class GlossaryManager(CollectionManager):
         response = await self._async_create_collection(body=body)
         return response
 
-    def create_glossary(self, display_name: str, description: str = None, language: str = "English",
-                               usage: str = None,
-                               category: str = None, body: dict | NewElementRequestBody = None) -> str:
-        """Create a new glossary with optional classification. """
+    def create_glossary(self, display_name: str, description: Optional[str] = None, language: str = "English",
+                               usage: Optional[str] = None,
+                               category: Optional[str] = None, body: Optional[dict | NewElementRequestBody] = None) -> str:
+        """Create a new glossary.
+
+        Parameters
+        ----------
+        display_name : str
+            The name of the glossary.
+        description : str, optional
+            The description of the glossary.
+        language : str, optional
+            The language of the glossary (default is "English").
+        usage : str, optional
+            The usage information for the glossary.
+        category : str, optional
+            The category for the glossary.
+        body : dict | NewElementRequestBody, optional
+            If provided, the request body for creating the glossary.
+
+        Returns
+        -------
+        str
+            The GUID of the newly created glossary.
+
+        Raises
+        ------
+        PyegeriaException
+            If there are issues in communications, message format, or Egeria errors.
+        """
         loop = asyncio.get_event_loop()
         response = loop.run_until_complete(
             self._async_create_glossary(display_name, description, language, usage, category, body)
             )
         return response
 
-    async def _async_delete_glossary(self, glossary_guid: str, body: dict | DeleteRequestBody = None,
+    async def _async_delete_glossary(self, glossary_guid: str, body: Optional[dict | DeleteElementRequestBody] = None,
                                      cascade: bool = False) -> None:
         """Delete glossary. Async version.
 
@@ -180,7 +208,7 @@ class GlossaryManager(CollectionManager):
 
         logger.info(f"Deleted glossary {glossary_guid} with cascade {cascade}")
 
-    def delete_glossary(self, glossary_guid: str, body: dict | DeleteRequestBody = None, cascade: bool = False) -> None:
+    def delete_glossary(self, glossary_guid: str, body: Optional[dict | DeleteElementRequestBody] = None, cascade: bool = False) -> None:
         """Delete a new glossary.
 
         Parameters
@@ -229,8 +257,8 @@ class GlossaryManager(CollectionManager):
 
 
 
-        await self._async_update_collection(glossary_guid, body, is_merge_update=merge_update)
-        logger.info(f"Updated digital subscription {glossary_guid}")
+        await self._async_update_collection(glossary_guid, body)
+        logger.info(f"Updated glossary {glossary_guid}")
 
     def update_glossary(
             self,
@@ -282,64 +310,22 @@ class GlossaryManager(CollectionManager):
     async def _async_create_glossary_term(
             self, body: dict | NewElementRequestBody
             ) -> str:
-        """Create a term for a  glossary.
-            See also: https://egeria-project.org/types/3/0385-Controlled-Glossary-Development/?h=controlled
-            The request body also supports the specification of an effective time for the query.
-
-            Async Version.
+        """Create a term for a glossary. Async version.
 
         Parameters
         ----------
-            body: dict | NewElementRequestBody
-                The dictionary to create glossary term for. Example below.
-
+        body : dict | NewElementRequestBody
+            The request body for creating the glossary term.
 
         Returns
         -------
-        str:
-            The unique guid for the created term.
+        str
+            The unique GUID for the created 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
-        -----
-
-        Sample body like:
-        {
-            "class" : "NewElementRequestBody",
-            "parentGUID" : "Glossary GUID here",
-            "isOwnAnchor" : true,
-            "anchorScopeGUID" : "Glossary GUID here",
-            "parentRelationshipTypeName" : "ParentGlossary",
-            "parentAtEnd1": true,
-            "properties" :
-                {
-                    "class" : "GlossaryTermProperties",
-                    "qualifiedName" : "GlossaryTerm::term name",
-                    "displayName" : "term name",
-                    "aliases": []
-                    "summary" : "This is the short description.",
-                    "description" : "This is the long description of the term.",
-                    "abbreviation" : "aabrev",
-                    "examples" : "Add examples and descriptions here.",
-                    "usage" : "This is how the concept described by the glossary term is used.",
-                    "versionIdentifier" : "V1.0",
-                    "category" : "A user defined category",
-                    "additionalProperties" :
-                    {
-                       "propertyName1" : "xxxx",
-                       "propertyName2" : "xxxx"
-                    }
-                },
-            "initialStatus" : "DRAFT"
-        }
-
+        PyegeriaException
+            If there are issues in communications, message format, or Egeria errors.
         """
 
         url = (
@@ -348,63 +334,22 @@ class GlossaryManager(CollectionManager):
         return await self._async_create_element_body_request(url, "GlossaryTermProperties", body)
 
     def create_glossary_term(self, body: dict | NewElementRequestBody) -> str:
-        """Create a term for a controlled glossary.
-            See also: https://egeria-project.org/types/3/0385-Controlled-Glossary-Development/?h=controlled
-            The request body also supports the specification of an effective time for the query.
+        """Create a term for a glossary.
 
         Parameters
         ----------
-
-            body: dict
-                The dictionary to create glossary term for. Example below.
-
+        body : dict | NewElementRequestBody
+            The request body for creating the glossary term.
 
         Returns
         -------
-        str:
-            The unique guid for the created term.
+        str
+            The unique GUID for the created 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
-        -----
-
-        Sample body like:
-         {
-            "class" : "NewElementRequestBody",
-            "parentGUID" : "Glossary GUID here",
-            "isOwnAnchor" : true,
-            "anchorScopeGUID" : "Glossary GUID here",
-            "parentRelationshipTypeName" : "ParentGlossary",
-            "parentAtEnd1": true,
-            "properties" :
-                {
-                    "class" : "GlossaryTermProperties",
-                    "qualifiedName" : "GlossaryTerm::term name",
-                    "displayName" : "term name",
-                    "aliases": []
-                    "summary" : "This is the short description.",
-                    "description" : "This is the long description of the term.",
-                    "abbreviation" : "aabrev",
-                    "examples" : "Add examples and descriptions here.",
-                    "usage" : "This is how the concept described by the glossary term is used.",
-                    "versionIdentifier" : "V1.0",
-                    "category" : "A user defined category",
-                    "additionalProperties" :
-                    {
-                       "propertyName1" : "xxxx",
-                       "propertyName2" : "xxxx"
-                    }
-                },
-            "initialStatus" : "DRAFT"
-        }
-
+        PyegeriaException
+            If there are issues in communications, message format, or Egeria errors.
         """
         loop = asyncio.get_event_loop()
         response = loop.run_until_complete(
@@ -452,9 +397,9 @@ class GlossaryManager(CollectionManager):
 
         Raises
         ------
-         InvalidParameterException
+         PyegeriaInvalidParameterException
              If the client passes incorrect parameters on the request - such as bad URLs or invalid values.
-         PropertyServerException
+         PyegeriaAPIException
              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.
@@ -513,7 +458,11 @@ class GlossaryManager(CollectionManager):
             term_info = []
             # check that the column headers are known
             if all(header in term_properties for header in headers) is False:
-                raise InvalidParameterException("Invalid headers in CSV File")
+                raise PyegeriaInvalidParameterException(
+                    None,
+                    context={"caller_method": "load_terms_from_csv"},
+                    additional_info={"reason": "Invalid headers in CSV File"},
+                )
 
             # process each row and validate values
             for row in csv_reader:
@@ -760,9 +709,9 @@ class GlossaryManager(CollectionManager):
             glossary_guid: str,
             glossary_term_guid: str,
             new_display_name: str,
-            version_id: str = None,
+            version_id: Optional[str] = None,
             term_status: str = "PROPOSED",
-            body: dict | TemplateRequestBody = None,
+            body: Optional[dict | TemplateRequestBody] = None,
             ) -> str:
         """Create a new term from an existing term.
 
@@ -789,9 +738,9 @@ class GlossaryManager(CollectionManager):
 
         Raises
         ------
-         InvalidParameterException
+         PyegeriaInvalidParameterException
              If the client passes incorrect parameters on the request - such as bad URLs or invalid values.
-         PropertyServerException
+         PyegeriaAPIException
              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.
@@ -810,37 +759,22 @@ class GlossaryManager(CollectionManager):
             body = {
                 "class" : "TemplateRequestBody",
                 "templateGUID": glossary_term_guid,
-                "replacementProperties": {
-                    "class": "ElementProperties",
-                    "propertyValueMap": {
-                        "qualifiedName": {
-                            "class": "PrimitiveTypePropertyValue",
-                            "typeName": "string",
-                            "primitiveValue": qualified_name,
-                            },
-
-                        "displayName": {
-                            "class": "PrimitiveTypePropertyValue",
-                            "typeName": "string",
-                            "primitiveValue": new_display_name,
-                            },
-
-                        # "publishVersionIdentifier": {
-                        #     "class": "PrimitiveTypePropertyValue",
-                        #     "typeName": "string",
-                        #     "primitiveValue": version_id,
-                        #     },
+                "parentGuid": glossary_guid,
+                "parentAtEnd1": True,
 
-                        }
+                "replacementProperties": {
+                    "class": "GlossaryTermProperties",
+                        "qualifiedName": qualified_name,
+                        "displayName":  new_display_name,
+                        "status": term_status,
+                        "versionIdentifier": version_id
                     },
-                "initialStatus": term_status,
                 }
             validated_body = self._template_request_adapter.validate_python(body)
-
+            validated_body._templateGUID = glossary_term_guid
         v_body = body_slimmer(validated_body.model_dump(exclude_none=True))
         logger.info(v_body)
 
-
         url = (
             f"{self.platform_url}/servers/{self.view_server}/api/open-metadata/glossary-manager/glossaries/"
             f"terms/from-template/{glossary_term_guid}"
@@ -856,9 +790,9 @@ class GlossaryManager(CollectionManager):
             glossary_guid: str,
             glossary_term_guid: str,
             new_display_name: str,
-            version_id: str = None,
+            version_id: Optional[str] = None,
             term_status: str = "PROPOSED",
-            body: dict | TemplateRequestBody = None,
+            body: Optional[dict | TemplateRequestBody] = None,
             ) -> str:
         """Create a new term from an existing term.
 
@@ -883,9 +817,9 @@ class GlossaryManager(CollectionManager):
 
         Raises
         ------
-         InvalidParameterException
+         PyegeriaInvalidParameterException
              If the client passes incorrect parameters on the request - such as bad URLs or invalid values.
-         PropertyServerException
+         PyegeriaAPIException
              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.
@@ -907,6 +841,7 @@ class GlossaryManager(CollectionManager):
 
         return response
 
+    @dynamic_catch
     async def _async_update_glossary_term(
             self,
             glossary_term_guid: str,
@@ -928,9 +863,9 @@ class GlossaryManager(CollectionManager):
 
         Raises
         ------
-         InvalidParameterException
+         PyegeriaInvalidParameterException
              If the client passes incorrect parameters on the request - such as bad URLs or invalid values.
-         PropertyServerException
+         PyegeriaAPIException
              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.
@@ -948,7 +883,7 @@ class GlossaryManager(CollectionManager):
         )
         await self._async_update_element_body_request(url, ["GlossaryTermProperties"], body)
         logger.info(f"Updated digital subscription {glossary_term_guid}")
-
+    @dynamic_catch
     def update_glossary_term(
             self,
             glossary_term_guid: str,
@@ -975,9 +910,9 @@ class GlossaryManager(CollectionManager):
 
         Raises
         ------
-         InvalidParameterException
+         PyegeriaInvalidParameterException
              If the client passes incorrect parameters on the request - such as bad URLs or invalid values.
-         PropertyServerException
+         PyegeriaAPIException
              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.
@@ -1004,103 +939,101 @@ class GlossaryManager(CollectionManager):
                 )
             )
 
-
     @dynamic_catch
-    async def _async_update_term_status(self, term_guid: str, status: str = None,
-                                              body: dict | UpdateStatusRequestBody = None):
-        """Update the status of a collection. Async version.
+    async def _async_update_glossary_term_status(
+            self,
+            glossary_term_guid: str,
+            term_status: str = "DRAFT",
+            body: Optional[dict | UpdateElementRequestBody] = None,
+    ) -> None:
+        """Update the status of a term. Async version.
 
         Parameters
         ----------
-        collection_guid: str
-            The guid of the collection to update.
-        status: str, optional
-            The new lifecycle status for the collection. Ignored, if the body is provided.
-        body: dict | UpdateStatusRequestBody, optional
-            A structure representing the details of the collection to create. If supplied, these details
-            supersede the status parameter provided.
+            glossary_term_guid: str
+                Unique identifier for the source glossary term.
+            term_status: str
+                new status of the term.
+            body: dict | UpdateElementRequestBody
+                Body containing information about the status change. Supersedes other parameters.
 
         Returns
         -------
-        Nothing
+        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
+         PyegeriaException
 
-        Notes
-        -----
-        JSON Structure looks like:
-         {
-          "class": "UpdateStatusRequestBody",
-          "status": "APPROVED",
-          "externalSourceGUID": "add guid here",
-          "externalSourceName": "add qualified name here",
-          "effectiveTime": "{{$isoTimestamp}}",
-          "forLineage": false,
-          "forDuplicateProcessing": false
-        }
         """
 
-        url = f"{self.platform_url}/servers/{self.view_server}/api/open-metadata/glossary-manager/metadata-elements/{term_guid}/update-status"
-        await self._async_update_status_request(url, status, body)
-        logger.info(f"Updated status for term {term_guid}")
+        validate_guid(glossary_term_guid)
+
+        if body is None:
+            body = {
+             "class": "UpdateElementRequestBody",
+             "contentStatus": term_status,
+             "mergeUpdate": True,
+            }
+        await self._async_update_glossary_term( glossary_term_guid, body)
+        logger.info(f"Updated term status {glossary_term_guid}")
+
 
     @dynamic_catch
-    def update_term_status(self, term_guid: str, status: str = None,
-                                 body: dict | UpdateStatusRequestBody = None):
-        """Update the status of a DigitalProduct collection.
+    def update_glossary_term_status(
+            self,
+            glossary_term_guid: str, term_status: str = "DRAFT",
+            body: Optional[dict | UpdateElementRequestBody] = None,
+            ) -> None:
+        """Add the data field values classification to a glossary term
+
+            Async Version.
 
         Parameters
         ----------
-        collection_guid: str
-            The guid of the collection to update.
-        status: str, optional
-            The new lifecycle status for the digital product. Ignored, if the body is provided.
-        body: dict | UpdateStatusRequestBody, optional
-            A structure representing the details of the collection to create. If supplied, these details
-            supersede the status parameter provided.
+            glossary_term_guid: str
+                Unique identifier for the source glossary term.
+            term_status: str
+                new status of the term.
+            body: dict | UpdateStatusRequestBody
+                Body containing information about the status change. Supersedes other parameters.
 
         Returns
         -------
-        Nothing
+        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
-
+         PyegeriaException
+             If the client passes incorrect parameters on the request - such as bad URLs or invalid values.
+         PyegeriaAPIException
+             Raised by the server when an issue arises in processing a valid request.
+         NotAuthoclearizedException
+             The principle specified by the user_id does not have authorization for the requested action.
         Notes
         -----
-        JSON Structure looks like:
-         {
-          "class": "UpdateStatusRequestBody",
-          "status": "APPROVED",
-          "externalSourceGUID": "add guid here",
-          "externalSourceName": "add qualified name here",
-          "effectiveTime": "{{$isoTimestamp}}",
-          "forLineage": false,
-          "forDuplicateProcessing": false
+        An example body is:
+
+        {
+            "class" : "UpdateStatusRequestBody",
+            "newStatus" : "DRAFT"
         }
+
         """
         loop = asyncio.get_event_loop()
-        loop.run_until_complete(self._async_update_collection_status(term_guid, status, body))
-
+        loop.run_until_complete(
+            self._async_update_glossary_term_status(
+                glossary_term_guid,
+                body,
+                )
+            )
 
+    @dynamic_catch
     async def _async_delete_term(
             self,
             term_guid: str,
             cascade: bool = False,
-            body: dict | DeleteRequestBody = None
+            body: Optional[dict | DeleteElementRequestBody] = None
             ) -> None:
         """Delete the glossary terms associated with the specified glossary. Async version.
 
@@ -1119,9 +1052,9 @@ class GlossaryManager(CollectionManager):
 
         Raises
         ------
-         InvalidParameterException
+         PyegeriaInvalidParameterException
              If the client passes incorrect parameters on the request - such as bad URLs or invalid values.
-         PropertyServerException
+         PyegeriaAPIException
              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.
@@ -1135,7 +1068,7 @@ class GlossaryManager(CollectionManager):
             f"{self.platform_url}/servers/{self.view_server}/api/open-metadata/glossary-manager/glossaries/"
             f"terms/{term_guid}/delete"
         )
-        await self._async_delete_request(url, body, cascade)
+        await self._async_delete_element_request(url, body, cascade)
         logger.info(f"Deleted collection {term_guid} with cascade {cascade}")
 
 
@@ -1143,7 +1076,7 @@ class GlossaryManager(CollectionManager):
             self,
             term_guid: str,
             cascade: bool = False,
-            body: dict | DeleteRequestBody = None
+            body: Optional[dict | DeleteElementRequestBody] = None
             ) -> None:
         """Delete the glossary terms associated with the specified glossary.
 
@@ -1162,9 +1095,9 @@ class GlossaryManager(CollectionManager):
 
         Raises
         ------
-         InvalidParameterException
+         PyegeriaInvalidParameterException
              If the client passes incorrect parameters on the request - such as bad URLs or invalid values.
-         PropertyServerException
+         PyegeriaAPIException
              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.
@@ -1180,7 +1113,7 @@ class GlossaryManager(CollectionManager):
             self,
             term_guid: str,
             glossary_guid: str,
-            body: dict | DeleteRequestBody = None
+            body: Optional[dict | DeleteRelationshipRequestBody] = None
             ) -> None:
         """Move the glossary terms to the specified glossary. Async version.
 
@@ -1196,9 +1129,9 @@ class GlossaryManager(CollectionManager):
 
         Raises
         ------
-         InvalidParameterException
+         PyegeriaInvalidParameterException
              If the client passes incorrect parameters on the request - such as bad URLs or invalid values.
-         PropertyServerException
+         PyegeriaAPIException
              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.
@@ -1212,7 +1145,7 @@ class GlossaryManager(CollectionManager):
             f"{self.platform_url}/servers/{self.view_server}/api/open-metadata/glossary-manager/glossaries/"
             f"terms/{term_guid}/move-to/{glossary_guid}"
         )
-        await self._async_delete_request(url, body)
+        await self._async_delete_relationship_request(url, body)
         logger.info(f"Moved collection {term_guid} to glossary {glossary_guid}")
 
 
@@ -1220,7 +1153,7 @@ class GlossaryManager(CollectionManager):
             self,
             term_guid: str,
             glossary_guid: str,
-            body: dict | DeleteRequestBody = None
+            body: Optional[dict | DeleteRelationshipRequestBody] = None
             ) -> None:
         """Move the glossary terms to the specified glossary.
 
@@ -1236,9 +1169,9 @@ class GlossaryManager(CollectionManager):
 
         Raises
         ------
-         InvalidParameterException
+         PyegeriaInvalidParameterException
              If the client passes incorrect parameters on the request - such as bad URLs or invalid values.
-         PropertyServerException
+         PyegeriaAPIException
              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.
@@ -1257,16 +1190,16 @@ class GlossaryManager(CollectionManager):
     #
 
 
+
+
     #
     #   From glossary browser
     #
 
 
 
-
-
     async def _async_add_is_abstract_concepts(
-            self, term_guid: str, body: dict | NewClassificationRequestBody = None,
+            self, term_guid: str, body: Optional[dict | NewClassificationRequestBody] = None,
             ) -> None:
         """Add a relationship between terms. Async Version.
 
@@ -1288,9 +1221,9 @@ class GlossaryManager(CollectionManager):
 
         Raises
         ------
-         InvalidParameterException
+         PyegeriaInvalidParameterException
              If the client passes incorrect parameters on the request - such as bad URLs or invalid values.
-         PropertyServerException
+         PyegeriaAPIException
              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.
@@ -1326,12 +1259,12 @@ class GlossaryManager(CollectionManager):
                     }
                 }
 
-        await self._async_new_classification_request(url, "AbstractConceptProperties",body)
+        await self._async_new_classification_request(url, "AbstractConceptProperties", body)
         logger.info(f"Added AbstractConcept classification to {term_guid}")
 
 
     def add_is_abstract_concept(
-            self, term_guid: str,  body: dict | NewClassificationRequestBody = None,
+            self, term_guid: str,  body: Optional[dict | NewClassificationRequestBody] = None,
             ) -> None:
         """Add a relationship between terms.
 
@@ -1352,9 +1285,9 @@ class GlossaryManager(CollectionManager):
 
         Raises
         ------
-         InvalidParameterException
+         PyegeriaInvalidParameterException
              If the client passes incorrect parameters on the request - such as bad URLs or invalid values.
-         PropertyServerException
+         PyegeriaAPIException
              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.
@@ -1387,7 +1320,7 @@ class GlossaryManager(CollectionManager):
             )
 
     async def _async_remove_is_abstract_concepts(
-            self, term_guid: str, body: dict | DeleteRequestBody = None,
+            self, term_guid: str, body: Optional[dict | DeleteClassificationRequestBody] = None,
             ) -> None:
         """Add a relationship between terms. Async Version.
 
@@ -1409,9 +1342,9 @@ class GlossaryManager(CollectionManager):
 
         Raises
         ------
-         InvalidParameterException
+         PyegeriaInvalidParameterException
              If the client passes incorrect parameters on the request - such as bad URLs or invalid values.
-         PropertyServerException
+         PyegeriaAPIException
              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.
@@ -1438,11 +1371,11 @@ class GlossaryManager(CollectionManager):
             f"{self.platform_url}/servers/{self.view_server}/api/open-metadata/glossary-manager/glossaries/"
             f"terms/{term_guid}/is-abstract-concept/remove"
         )
-        await self._async_delete_request(url, body)
+        await self._async_delete_classification_request(url, body)
         logger.info(f"Removed AbstractConcept classification to {term_guid}")
 
     def remove_is_abstract_concept(
-            self, term_guid: str, body: dict | DeleteRequestBody = None,
+            self, term_guid: str, body: Optional[dict | DeleteClassificationRequestBody] = None,
             ) -> None:
         """Add a relationship between terms.
 
@@ -1463,9 +1396,9 @@ class GlossaryManager(CollectionManager):
 
         Raises
         ------
-         InvalidParameterException
+         PyegeriaInvalidParameterException
              If the client passes incorrect parameters on the request - such as bad URLs or invalid values.
-         PropertyServerException
+         PyegeriaAPIException
              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.
@@ -1499,7 +1432,7 @@ class GlossaryManager(CollectionManager):
 
 
     async def _async_add_is_context_definition(
-            self, term_guid: str, body: dict | NewClassificationRequestBody = None,
+            self, term_guid: str, body: Optional[dict | NewClassificationRequestBody] = None,
             ) -> None:
         """Add a relationship between terms. Async Version.
 
@@ -1521,9 +1454,9 @@ class GlossaryManager(CollectionManager):
 
         Raises
         ------
-         InvalidParameterException
+         PyegeriaInvalidParameterException
              If the client passes incorrect parameters on the request - such as bad URLs or invalid values.
-         PropertyServerException
+         PyegeriaAPIException
              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.
@@ -1559,13 +1492,13 @@ class GlossaryManager(CollectionManager):
                     }
                 }
 
-        await self._async_new_classification_request(url, "ContextDefinitionProperties",body)
+        await self._async_new_classification_request(url, "ContextDefinitionProperties", body)
         logger.info(f"Added AbstractConcept classification to {term_guid}")
 
 
 
     def add_is_context_definition(
-            self, term_guid: str,  body: dict | NewClassificationRequestBody = None,
+            self, term_guid: str,  body: Optional[dict | NewClassificationRequestBody] = None,
             ) -> None:
         """Add a relationship between terms.
 
@@ -1586,9 +1519,9 @@ class GlossaryManager(CollectionManager):
 
         Raises
         ------
-         InvalidParameterException
+         PyegeriaInvalidParameterException
              If the client passes incorrect parameters on the request - such as bad URLs or invalid values.
-         PropertyServerException
+         PyegeriaAPIException
              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.
@@ -1621,7 +1554,7 @@ class GlossaryManager(CollectionManager):
             )
 
     async def _async_remove_is_context_definition(
-            self, term_guid: str, body: dict | DeleteRequestBody = None,
+            self, term_guid: str, body: Optional[dict | DeleteClassificationRequestBody] = None,
             ) -> None:
         """Add a relationship between terms. Async Version.
 
@@ -1643,9 +1576,9 @@ class GlossaryManager(CollectionManager):
 
         Raises
         ------
-         InvalidParameterException
+         PyegeriaInvalidParameterException
              If the client passes incorrect parameters on the request - such as bad URLs or invalid values.
-         PropertyServerException
+         PyegeriaAPIException
              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.
@@ -1672,11 +1605,11 @@ class GlossaryManager(CollectionManager):
             f"{self.platform_url}/servers/{self.view_server}/api/open-metadata/glossary-manager/glossaries/"
             f"terms/{term_guid}/is-context-definition/remove"
         )
-        await self._async_delete_request(url, body)
+        await self._async_delete_classification_request(url, body)
         logger.info(f"Removed ContextDefinition classification to {term_guid}")
 
     def remove_is_context_definition(
-            self, term_guid: str, body: dict | DeleteRequestBody = None,
+            self, term_guid: str, body: Optional[dict | DeleteClassificationRequestBody] = None,
             ) -> None:
         """Add a relationship between terms.
 
@@ -1697,9 +1630,9 @@ class GlossaryManager(CollectionManager):
 
         Raises
         ------
-         InvalidParameterException
+         PyegeriaInvalidParameterException
              If the client passes incorrect parameters on the request - such as bad URLs or invalid values.
-         PropertyServerException
+         PyegeriaAPIException
              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.
@@ -1733,7 +1666,7 @@ class GlossaryManager(CollectionManager):
 
 
     async def _async_add_is_data_value(
-            self, term_guid: str, body: dict | NewClassificationRequestBody = None,
+            self, term_guid: str, body: Optional[dict | NewClassificationRequestBody] = None,
             ) -> None:
         """Add a relationship between terms. Async Version.
 
@@ -1755,9 +1688,9 @@ class GlossaryManager(CollectionManager):
 
         Raises
         ------
-         InvalidParameterException
+         PyegeriaInvalidParameterException
              If the client passes incorrect parameters on the request - such as bad URLs or invalid values.
-         PropertyServerException
+         PyegeriaAPIException
              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.
@@ -1793,13 +1726,13 @@ class GlossaryManager(CollectionManager):
                     }
                 }
 
-        await self._async_new_classification_request(url, "DataValueProperties",body)
+        await self._async_new_classification_request(url, "DataValueProperties", body)
         logger.info(f"Added DataValue classification to {term_guid}")
 
 
 
     def add_is_data_value(
-            self, term_guid: str,  body: dict | NewClassificationRequestBody = None,
+            self, term_guid: str,  body: Optional[dict | NewClassificationRequestBody] = None,
             ) -> None:
         """Add a relationship between terms.
 
@@ -1820,9 +1753,9 @@ class GlossaryManager(CollectionManager):
 
         Raises
         ------
-         InvalidParameterException
+         PyegeriaInvalidParameterException
              If the client passes incorrect parameters on the request - such as bad URLs or invalid values.
-         PropertyServerException
+         PyegeriaAPIException
              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.
@@ -1855,7 +1788,7 @@ class GlossaryManager(CollectionManager):
             )
 
     async def _async_remove_is_data_value(
-            self, term_guid: str, body: dict | DeleteRequestBody = None,
+            self, term_guid: str, body: Optional[dict | DeleteClassificationRequestBody] = None,
             ) -> None:
         """Add a relationship between terms. Async Version.
 
@@ -1877,9 +1810,9 @@ class GlossaryManager(CollectionManager):
 
         Raises
         ------
-         InvalidParameterException
+         PyegeriaInvalidParameterException
              If the client passes incorrect parameters on the request - such as bad URLs or invalid values.
-         PropertyServerException
+         PyegeriaAPIException
              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.
@@ -1906,11 +1839,11 @@ class GlossaryManager(CollectionManager):
             f"{self.platform_url}/servers/{self.view_server}/api/open-metadata/glossary-manager/glossaries/"
             f"terms/{term_guid}/is-data-value/remove"
         )
-        await self._async_delete_request(url, body)
+        await self._async_delete_classification_request(url, body)
         logger.info(f"Removed DataValue classification to {term_guid}")
 
     def remove_is_data_value(
-            self, term_guid: str, body: dict | DeleteRequestBody = None,
+            self, term_guid: str, body: Optional[dict | DeleteClassificationRequestBody] = None,
             ) -> None:
         """Add a relationship between terms.
 
@@ -1931,9 +1864,9 @@ class GlossaryManager(CollectionManager):
 
         Raises
         ------
-         InvalidParameterException
+         PyegeriaInvalidParameterException
              If the client passes incorrect parameters on the request - such as bad URLs or invalid values.
-         PropertyServerException
+         PyegeriaAPIException
              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.
@@ -1967,7 +1900,7 @@ class GlossaryManager(CollectionManager):
         
         
     async def _async_add_activity_description(
-            self, term_guid: str, activity_type: int = None, body: dict | NewClassificationRequestBody = None,
+            self, term_guid: str, activity_type: int = None, body: Optional[dict | NewClassificationRequestBody] = None,
             ) -> None:
         """Add a relationship between terms. Async Version.
 
@@ -1989,9 +1922,9 @@ class GlossaryManager(CollectionManager):
 
         Raises
         ------
-         InvalidParameterException
+         PyegeriaInvalidParameterException
              If the client passes incorrect parameters on the request - such as bad URLs or invalid values.
-         PropertyServerException
+         PyegeriaAPIException
              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.
@@ -2027,13 +1960,13 @@ class GlossaryManager(CollectionManager):
             f"{self.platform_url}/servers/{self.view_server}/api/open-metadata/glossary-manager/glossaries/"
             f"terms/{term_guid}/is-activity"
         )
-        await self._async_new_classification_request(url, "ActivityDescriptionProperties",body)
+        await self._async_new_classification_request(url, "ActivityDescriptionProperties", body)
         logger.info(f"Added DataValue classification to {term_guid}")
 
 
 
     def add_activity_description(
-            self, term_guid: str,  activity_type: int = None, body: dict | NewClassificationRequestBody = None,
+            self, term_guid: str,  activity_type: int = None, body: Optional[dict | NewClassificationRequestBody] = None,
             ) -> None:
         """Add a relationship between terms.
 
@@ -2054,9 +1987,9 @@ class GlossaryManager(CollectionManager):
 
         Raises
         ------
-         InvalidParameterException
+         PyegeriaInvalidParameterException
              If the client passes incorrect parameters on the request - such as bad URLs or invalid values.
-         PropertyServerException
+         PyegeriaAPIException
              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.
@@ -2089,7 +2022,7 @@ class GlossaryManager(CollectionManager):
             )
 
     async def _async_remove_activity_description(
-            self, term_guid: str, body: dict | DeleteRequestBody = None,
+            self, term_guid: str, body: Optional[dict | DeleteClassificationRequestBody] = None,
             ) -> None:
         """Add a relationship between terms. Async Version.
 
@@ -2111,9 +2044,9 @@ class GlossaryManager(CollectionManager):
 
         Raises
         ------
-         InvalidParameterException
+         PyegeriaInvalidParameterException
              If the client passes incorrect parameters on the request - such as bad URLs or invalid values.
-         PropertyServerException
+         PyegeriaAPIException
              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.
@@ -2140,11 +2073,11 @@ class GlossaryManager(CollectionManager):
             f"{self.platform_url}/servers/{self.view_server}/api/open-metadata/glossary-manager/glossaries/"
             f"terms/{term_guid}/is-activity/remove"
         )
-        await self._async_delete_request(url, body)
+        await self._async_delete_classification_request(url, body)
         logger.info(f"Removed ActivityDescription classification to {term_guid}")
 
     def remove_activity_description(
-            self, term_guid: str, body: dict | DeleteRequestBody = None,
+            self, term_guid: str, body: Optional[dict | DeleteClassificationRequestBody] = None,
             ) -> None:
         """Add a relationship between terms.
 
@@ -2165,9 +2098,9 @@ class GlossaryManager(CollectionManager):
 
         Raises
         ------
-         InvalidParameterException
+         PyegeriaInvalidParameterException
              If the client passes incorrect parameters on the request - such as bad URLs or invalid values.
-         PropertyServerException
+         PyegeriaAPIException
              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.
@@ -2204,7 +2137,7 @@ class GlossaryManager(CollectionManager):
     #
 
     async def _async_add_relationship_between_terms(
-            self, term1_guid: str, term2_guid: str, relationship_type: str, body: dict | NewRelationshipRequestBody = None,
+            self, term1_guid: str, term2_guid: str, relationship_type: str, body: Optional[dict | NewRelationshipRequestBody] = None,
             ) -> None:
         """Add a relationship between terms. Async Version.
 
@@ -2226,9 +2159,9 @@ class GlossaryManager(CollectionManager):
 
         Raises
         ------
-         InvalidParameterException
+         PyegeriaInvalidParameterException
              If the client passes incorrect parameters on the request - such as bad URLs or invalid values.
-         PropertyServerException
+         PyegeriaAPIException
              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.
@@ -2261,9 +2194,9 @@ class GlossaryManager(CollectionManager):
 
         if body is None:
             body = {
-                "class": "RelationshipRequestBody",
+                "class": "NewRelationshipRequestBody",
                 "properties":
-                    {"class": "GlossaryTermRelationship", }
+                    {"class": "GlossaryTermRelationship" }
                 }
 
 
@@ -2276,7 +2209,7 @@ class GlossaryManager(CollectionManager):
         logger.info(f"Added relationship between {term1_guid} and {term2_guid} of type {relationship_type}")
 
     def add_relationship_between_terms(
-            self, term1_guid: str, term2_guid: str, relationship_type: str, body: dict | NewRelationshipRequestBody = None,
+            self, term1_guid: str, term2_guid: str, relationship_type: str, body: Optional[dict | NewRelationshipRequestBody] = None,
             ) -> None:
         """Add a relationship between terms.
 
@@ -2297,9 +2230,9 @@ class GlossaryManager(CollectionManager):
 
         Raises
         ------
-         InvalidParameterException
+         PyegeriaInvalidParameterException
              If the client passes incorrect parameters on the request - such as bad URLs or invalid values.
-         PropertyServerException
+         PyegeriaAPIException
              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.
@@ -2333,7 +2266,7 @@ class GlossaryManager(CollectionManager):
             )
 
     async def _async_update_relationship_between_terms(
-            self, term1_guid: str, term2_guid: str, relationship_type: str, body: dict | UpdateRelationshipRequestBody = None
+            self, term1_guid: str, term2_guid: str, relationship_type: str, body: Optional[dict | UpdateRelationshipRequestBody] = None
             ) -> None:
 
         """Update a relationship between terms. Async Version.
@@ -2355,9 +2288,9 @@ class GlossaryManager(CollectionManager):
 
         Raises
         ------
-         InvalidParameterException
+         PyegeriaInvalidParameterException
              If the client passes incorrect parameters on the request - such as bad URLs or invalid values.
-         PropertyServerException
+         PyegeriaAPIException
              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.
@@ -2398,7 +2331,7 @@ class GlossaryManager(CollectionManager):
         logger.info(f"Updated relationship between {term1_guid} and {term2_guid} of type {relationship_type}")
 
     def update_relationship_between_terms(
-            self, term1_guid: str, term2_guid: str, relationship_type: str, body: dict | UpdateRelationshipRequestBody = None
+            self, term1_guid: str, term2_guid: str, relationship_type: str, body: Optional[dict | UpdateRelationshipRequestBody] = None
             ) -> None:
         """Update a relationship between terms.
 
@@ -2420,9 +2353,9 @@ class GlossaryManager(CollectionManager):
 
         Raises
         ------
-         InvalidParameterException
+         PyegeriaInvalidParameterException
              If the client passes incorrect parameters on the request - such as bad URLs or invalid values.
-         PropertyServerException
+         PyegeriaAPIException
              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.
@@ -2456,7 +2389,7 @@ class GlossaryManager(CollectionManager):
             )
 
     async def _async_remove_relationship_between_terms(
-            self, term1_guid: str, term2_guid: str, relationship_type: str, body: dict | DeleteRequestBody = None,
+            self, term1_guid: str, term2_guid: str, relationship_type: str, body: Optional[dict | DeleteRelationshipRequestBody] = None,
             ) -> None:
         """Remove a relationship between terms. Async Version.
 
@@ -2481,9 +2414,9 @@ class GlossaryManager(CollectionManager):
 
         Raises
         ------
-         InvalidParameterException
+         PyegeriaInvalidParameterException
              If the client passes incorrect parameters on the request - such as bad URLs or invalid values.
-         PropertyServerException
+         PyegeriaAPIException
              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.
@@ -2500,10 +2433,10 @@ class GlossaryManager(CollectionManager):
             f"terms/{term1_guid}/relationships/{relationship_type}/terms/{term2_guid}/remove"
         )
 
-        await self._async_delete_request(url, body)
+        await self._async_delete_relationship_request(url, body)
 
     def remove_relationship_between_terms(
-            self, term1_guid: str, term2_guid: str, relationship_type: str, body: dict | DeleteRequestBody = None) -> None:
+            self, term1_guid: str, term2_guid: str, relationship_type: str, body: Optional[dict | DeleteRelationshipRequestBody] = None) -> None:
 
         """Remove a relationship between terms.
 
@@ -2524,9 +2457,9 @@ class GlossaryManager(CollectionManager):
 
         Raises
         ------
-         InvalidParameterException
+         PyegeriaInvalidParameterException
              If the client passes incorrect parameters on the request - such as bad URLs or invalid values.
-         PropertyServerException
+         PyegeriaAPIException
              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.
@@ -2543,84 +2476,90 @@ class GlossaryManager(CollectionManager):
     #
 
     def _extract_glossary_properties(self, element: dict, columns_struct: dict) -> dict:
-        props = element.get('properties', {}) or {}
-        normalized = {
-            'properties': props,
-            'elementHeader': element.get('elementHeader', {}),
-        }
-        col_data = populate_columns_from_properties(normalized, columns_struct)
-        columns_list = col_data.get('formats', {}).get('columns', [])
+        """Extract glossary columns for rendering.
+
+        This extractor uses `populate_common_columns` for standard fields (properties, header, relationships,
+        subject area, mermaid). It then overlays glossary-specific values such as:
+        - categories_names: comma/newline separated Display Names of categories in the glossary
+        - categories_qualified_names: comma/newline separated Qualified Names of categories in the glossary
+
+        Parameters
+        ----------
+        element : dict
+            Raw element as returned by the OMVS.
+        columns_struct : dict
+            The selected output format structure (from _output_formats), whose columns' `value` fields will be filled.
+
+        Returns
+        -------
+        dict
+            The same columns_struct with values populated. Non-empty values are not overwritten.
+        """
+        # Common population first
+        col_data = populate_common_columns(element, columns_struct)
+        # Overlay glossary-specific extras: categories lists
         header_props = _extract_referenceable_properties(element)
         guid = header_props.get('GUID')
-        for column in columns_list:
-            key = column.get('key')
-            if key in header_props:
-                column['value'] = header_props.get(key)
-            elif isinstance(key, str) and key.lower() == 'guid':
-                column['value'] = guid
+        extra: dict = {}
         if guid:
-            categories = None
             try:
                 categories = self.get_categories_for_glossary(guid)
             except Exception:
                 categories = None
-            cat_display_list = []
-            cat_qn_list = []
             if isinstance(categories, list):
+                cat_display_list = []
+                cat_qn_list = []
                 for category in categories:
                     gcp = category.get('glossaryCategoryProperties', {})
-                    dn = gcp.get('displayName', '') or ''
-                    qn = gcp.get('qualifiedName', '') or ''
+                    dn = (gcp.get('displayName') or '')
+                    qn = (gcp.get('qualifiedName') or '')
                     if dn:
                         cat_display_list.append(dn)
                     if qn:
                         cat_qn_list.append(qn)
-            cat_names_md = (", \n".join(cat_display_list)).rstrip(',') if cat_display_list else ''
-            cat_qn_md = (", \n".join(cat_qn_list)).rstrip(',') if cat_qn_list else ''
-            for column in columns_list:
-                if column.get('key') == 'categories_names' and not column.get('value'):
-                    column['value'] = cat_names_md
-                if column.get('key') == 'categories_qualified_names' and not column.get('value'):
-                    column['value'] = cat_qn_md
-        for column in columns_list:
-            if column.get('key') == 'mermaid' and not column.get('value'):
-                column['value'] = element.get('mermaidGraph', '') or ''
-                break
-        return col_data
+                if cat_display_list:
+                    extra['categories_names'] = ", \n".join(cat_display_list)
+                if cat_qn_list:
+                    extra['categories_qualified_names'] = ", \n".join(cat_qn_list)
+        return overlay_additional_values(col_data, extra)
 
     def _extract_term_properties(self, element: dict, columns_struct: dict) -> dict:
-        col_data = populate_columns_from_properties(element, columns_struct)
-        columns_list = col_data.get("formats", {}).get("columns", [])
-        header_props = _extract_referenceable_properties(element)
-        for column in columns_list:
-            key = column.get('key')
-            if key in header_props:
-                column['value'] = header_props.get(key)
-            elif isinstance(key, str) and key.lower() == 'guid':
-                column['value'] = header_props.get('GUID')
-        classification_names = ""
-        classifications = element.get('elementHeader', {}).get("collectionCategories", [])
-        for classification in classifications:
-            classification_names += f"{classification['classificationName']}, "
-        if classification_names:
-            for column in columns_list:
-                if column.get('key') == 'classifications':
-                    column['value'] = classification_names[:-2]
-                    break
-        col_data = get_required_relationships(element, col_data)
-        subject_area = element.get('elementHeader', {}).get("subjectArea", "") or ""
-        subj_val = ""
-        if isinstance(subject_area, dict):
-            subj_val = subject_area.get("classificationProperties", {}).get("subjectAreaName", "")
-        for column in columns_list:
-            if column.get('key') == 'subject_area':
-                column['value'] = subj_val
-                break
-        mermaid_val = element.get('mermaidGraph', "") or ""
-        for column in columns_list:
-            if column.get('key') == 'mermaid':
-                column['value'] = mermaid_val
-                break
+        """Extract glossary term columns for rendering.
+
+        Populates standard columns via `populate_common_columns`, and if requested by the
+        selected columns, derives a classifications string (from `elementHeader.collectionCategories`)
+        into the `classifications` column.
+
+        Parameters
+        ----------
+        element : dict
+            Raw term element returned by the OMVS.
+        columns_struct : dict
+            The chosen format-set structure whose column `value`s will be set.
+
+        Returns
+        -------
+        dict
+            The same `columns_struct` with values populated.
+        """
+        # Use centralized population
+        col_data = populate_common_columns(element, columns_struct)
+        # Term-specific classifications (collectionCategories) to 'classifications' column
+        columns_list = col_data.get('formats', {}).get('attributes', [])
+        try:
+            classification_names = ""
+            classifications = element.get('elementHeader', {}).get("collectionCategories", [])
+            for classification in classifications:
+                nm = classification.get('classificationName')
+                if nm:
+                    classification_names += f"{nm}, "
+            if classification_names:
+                for column in columns_list:
+                    if column.get('key') == 'classifications' and column.get('value') in (None, ""):
+                        column['value'] = classification_names[:-2]
+                        break
+        except Exception:
+            pass
         return col_data
 
     def _get_term_additional_properties(self, element: dict, term_guid: str, output_format: str = None) -> dict:
@@ -2664,19 +2603,9 @@ class GlossaryManager(CollectionManager):
     def _generate_glossary_output(self, elements: dict | list[dict], search_string: str,
                                   element_type_name: str | None,
                                   output_format: str = 'DICT',
-                                  output_format_set: dict | str = None) -> str | list[dict]:
+                                  report_spec: dict | str = None) -> str | list[dict]:
         entity_type = 'Glossary'
-        if output_format_set:
-            if isinstance(output_format_set, str):
-                output_formats = select_output_format_set(output_format_set, output_format)
-            elif isinstance(output_format_set, dict):
-                output_formats = get_output_format_type_match(output_format_set, output_format)
-            else:
-                output_formats = None
-        else:
-            output_formats = select_output_format_set(entity_type, output_format)
-        if output_formats is None:
-            output_formats = select_output_format_set('Default', output_format)
+        output_formats = resolve_output_formats(entity_type, output_format, report_spec)
         return generate_output(
             elements=elements,
             search_string=search_string,
@@ -2690,19 +2619,9 @@ class GlossaryManager(CollectionManager):
     def _generate_term_output(self, elements: dict | list[dict], search_string: str,
                                element_type_name: str | None,
                                output_format: str = 'DICT',
-                               output_format_set: dict | str = None) -> str | list[dict]:
+                               report_spec: dict | str = None) -> str | list[dict]:
         entity_type = 'GlossaryTerm'
-        if output_format_set:
-            if isinstance(output_format_set, str):
-                output_formats = select_output_format_set(output_format_set, output_format)
-            elif isinstance(output_format_set, dict):
-                output_formats = get_output_format_type_match(output_format_set, output_format)
-            else:
-                output_formats = None
-        else:
-            output_formats = select_output_format_set(entity_type, output_format)
-        if output_formats is None:
-            output_formats = select_output_format_set('Default', output_format)
+        output_formats = resolve_output_formats(entity_type, output_format, report_spec)
         return generate_output(
             elements=elements,
             search_string=search_string,
@@ -2757,69 +2676,280 @@ class GlossaryManager(CollectionManager):
         response = loop.run_until_complete(self._async_get_term_relationship_types())
         return response
 
-    async def _async_find_glossaries(self, search_string: str = "*", classificaton_names: list[str] = None,
-                                     metadata_element_types: list[str] = ["Glossary"],
-                                     starts_with: bool = False, ends_with: bool = False, ignore_case: bool = False,
-                                     start_from: int = 0,page_size: int = 0, output_format: str = 'JSON',
-                                     output_format_set: str | dict  = None,
-                                     body: dict | SearchStringRequestBody = None) -> list | str:
+    @dynamic_catch
+    async def _async_find_glossaries(self, search_string: str = "*",
+                                     starts_with: bool = True, ends_with: bool = False,
+                                     ignore_case: bool = False,
+                                     anchor_domain: Optional[str] = None,
+                                     metadata_element_type: str = "Glossary",
+                                     metadata_element_subtypes: Optional[list[str]] = None,
+                                     skip_relationships: Optional[list[str]] = None,
+                                     include_only_relationships: Optional[list[str]] = None,
+                                     skip_classified_elements: Optional[list[str]] = None,
+                                     include_only_classified_elements: Optional[list[str]] = None,
+                                     graph_query_depth: int = 3,
+                                     governance_zone_filter: Optional[list[str]] = None, as_of_time: Optional[str] = None,
+                                     effective_time: Optional[str] = None, relationship_page_size: int = 0,
+                                     limit_results_by_status: Optional[list[str]] = None, sequencing_order: Optional[str] = None,
+                                     sequencing_property: Optional[str] = None,
+                                     output_format: str = "JSON",
+                                     report_spec: str | dict = None,
+                                     start_from: int = 0, page_size: int = 100,
+                                     property_names: Optional[list[str]] = None,
+                                     body: Optional[dict | SearchStringRequestBody] = None) -> list | str:
+        """ Retrieve the list of glossary metadata elements that contain the search string. Async Version.
 
-        response = await self._async_find_collections(search_string, classificaton_names,
-                                                      metadata_element_types, starts_with, ends_with, ignore_case,
-                                                      start_from, page_size, output_format, output_format_set, body)
-        return response
+        Parameters
+        ----------
+        search_string: str
+            Search string to match against - None or '*' indicate match against all glossaries.
+        starts_with : bool, [default=True], 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
+        anchor_domain: str, optional
+            The anchor domain to search in.
+        metadata_element_type: str, optional, [default="Glossary"]
+            The type of metadata element to search for.
+        metadata_element_subtypes: list[str], optional
+            The subtypes of metadata element to search for.
+        skip_relationships: list[str], optional
+            The types of relationships to skip.
+        include_only_relationships: list[str], optional
+            The types of relationships to include.
+        skip_classified_elements: list[str], optional
+            The types of classified elements to skip.
+        include_only_classified_elements: list[str], optional
+            The types of classified elements to include.
+        graph_query_depth: int, [default=3], optional
+            The depth of the graph query.
+        governance_zone_filter: list[str], optional
+            The governance zones to search in.
+        as_of_time: str, optional
+            The time to search as of.
+        effective_time: str, optional
+            The effective time to search at.
+        relationship_page_size: int, [default=0], optional
+            The page size for relationships.
+        limit_results_by_status: list[str], optional
+            The statuses to limit results by.
+        sequencing_order: str, optional
+            The order to sequence results by.
+        sequencing_property: str, optional
+            The property to sequence results by.
+        output_format: str, default = "JSON"
+            - one of "MD", "LIST", "FORM", "REPORT", "DICT", "MERMAID" or "JSON"
+        report_spec: str | dict , optional, default = None
+            - The desired output columns/fields to include.
+        start_from: int, [default=0], optional
+            When multiple pages of results are available, the page number to start from.
+        page_size: int, [default=100]
+            The number of items to return in a single page.
+        property_names: list[str], optional
+            The names of properties to search for.
+        body: dict | SearchStringRequestBody, optional, default = None
+            - if provided, the search parameters in the body will supercede other attributes, such as "search_string"
 
-    def find_glossaries(self, search_string: str = "*", classificaton_names: list[str] = None,
-                                     metadata_element_types: list[str] = ["Glossary"],
-                                     starts_with: bool = False, ends_with: bool = False, ignore_case: bool = False,
-                                     start_from: int = 0,page_size: int = 0, output_format: str = 'JSON',
-                                     output_format_set: str | dict  = None,
-                                     body: dict | SearchStringRequestBody = None) -> list | str:
-        loop = asyncio.get_event_loop()
-        response = loop.run_until_complete(
-                    self._async_find_glossaries(search_string,  classificaton_names, metadata_element_types, starts_with, ends_with, ignore_case, start_from, page_size, output_format, output_format_set, body))
+        Returns
+        -------
+        List | str
+
+        Output depends on the output format specified.
+
+        Raises
+        ------
+
+        ValidationError
+          If the client passes incorrect parameters on the request that don't conform to the data model.
+        PyegeriaException
+          Issues raised in communicating or server side processing.
+        NotAuthorizedException
+          The principle specified by the user_id does not have authorization for the requested action
+
+        """
+        response = await self._async_find_collections(search_string=search_string, starts_with=starts_with,
+                                                      ends_with=ends_with, ignore_case=ignore_case,
+                                                      anchor_domain=anchor_domain,
+                                                      metadata_element_type=metadata_element_type,
+                                                      metadata_element_subtypes=metadata_element_subtypes,
+                                                      skip_relationships=skip_relationships,
+                                                      include_only_relationships=include_only_relationships,
+                                                      skip_classified_elements=skip_classified_elements,
+                                                      include_only_classified_elements=include_only_classified_elements,
+                                                      graph_query_depth=graph_query_depth,
+                                                      governance_zone_filter=governance_zone_filter,
+                                                      as_of_time=as_of_time, effective_time=effective_time,
+                                                      relationship_page_size=relationship_page_size,
+                                                      limit_results_by_status=limit_results_by_status,
+                                                      sequencing_order=sequencing_order,
+                                                      sequencing_property=sequencing_property,
+                                                      output_format=output_format, report_spec=report_spec,
+                                                      start_from=start_from, page_size=page_size,
+                                                      property_names=property_names, body=body)
         return response
 
-    async def _async_get_glossaries_by_name(self, filter_string: str = None, classification_names: list[str] = None,
-                                             body: dict | FilterRequestBody = None,
+    @dynamic_catch
+    def find_glossaries(self, search_string: str = "*",
+                        starts_with: bool = True, ends_with: bool = False,
+                        ignore_case: bool = False,
+                        anchor_domain: Optional[str] = None,
+                        metadata_element_type: str = "Glossary",
+                        metadata_element_subtypes: Optional[list[str]] = None,
+                        skip_relationships: Optional[list[str]] = None,
+                        include_only_relationships: Optional[list[str]] = None,
+                        skip_classified_elements: Optional[list[str]] = None,
+                        include_only_classified_elements: Optional[list[str]] = None,
+                        graph_query_depth: int = 3,
+                        governance_zone_filter: Optional[list[str]] = None, as_of_time: Optional[str] = None,
+                        effective_time: Optional[str] = None, relationship_page_size: int = 0,
+                        limit_results_by_status: Optional[list[str]] = None, sequencing_order: Optional[str] = None,
+                        sequencing_property: Optional[str] = None,
+                        output_format: str = "JSON",
+                        report_spec: str | dict = None,
+                        start_from: int = 0, page_size: int = 100,
+                        property_names: Optional[list[str]] = None,
+                        body: Optional[dict | SearchStringRequestBody] = None) -> list | str:
+        """ Retrieve the list of glossary metadata elements that contain the search string.
+
+        Parameters
+        ----------
+        search_string: str
+            Search string to match against - None or '*' indicate match against all glossaries.
+        starts_with : bool, [default=True], 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
+        anchor_domain: str, optional
+            The anchor domain to search in.
+        metadata_element_type: str, optional, [default="Glossary"]
+            The type of metadata element to search for.
+        metadata_element_subtypes: list[str], optional
+            The subtypes of metadata element to search for.
+        skip_relationships: list[str], optional
+            The types of relationships to skip.
+        include_only_relationships: list[str], optional
+            The types of relationships to include.
+        skip_classified_elements: list[str], optional
+            The types of classified elements to skip.
+        include_only_classified_elements: list[str], optional
+            The types of classified elements to include.
+        graph_query_depth: int, [default=3], optional
+            The depth of the graph query.
+        governance_zone_filter: list[str], optional
+            The governance zones to search in.
+        as_of_time: str, optional
+            The time to search as of.
+        effective_time: str, optional
+            The effective time to search at.
+        relationship_page_size: int, [default=0], optional
+            The page size for relationships.
+        limit_results_by_status: list[str], optional
+            The statuses to limit results by.
+        sequencing_order: str, optional
+            The order to sequence results by.
+        sequencing_property: str, optional
+            The property to sequence results by.
+        output_format: str, default = "JSON"
+            - one of "MD", "LIST", "FORM", "REPORT", "DICT", "MERMAID" or "JSON"
+        report_spec: str | dict , optional, default = None
+            - The desired output columns/fields to include.
+        start_from: int, [default=0], optional
+            When multiple pages of results are available, the page number to start from.
+        page_size: int, [default=100]
+            The number of items to return in a single page.
+        property_names: list[str], optional
+            The names of properties to search for.
+        body: dict | SearchStringRequestBody, optional, default = None
+            - if provided, the search parameters in the body will supercede other attributes, such as "search_string"
+
+        Returns
+-------
+        List | str
+
+        Output depends on the output format specified.
+
+        Raises
+-------
+
+        ValidationError
+          If the client passes incorrect parameters on the request that don't conform to the data model.
+        PyegeriaException
+          Issues raised in communicating or server side processing.
+        NotAuthorizedException
+          The principle specified by the user_id does not have authorization for the requested action
+
+        """
+        loop = asyncio.get_event_loop()
+        return loop.run_until_complete(self._async_find_glossaries(search_string=search_string,
+                                                                  starts_with=starts_with,
+                                                                  ends_with=ends_with,
+                                                                  ignore_case=ignore_case,
+                                                                  anchor_domain=anchor_domain,
+                                                                  metadata_element_type=metadata_element_type,
+                                                                  metadata_element_subtypes=metadata_element_subtypes,
+                                                                  skip_relationships=skip_relationships,
+                                                                  include_only_relationships=include_only_relationships,
+                                                                  skip_classified_elements=skip_classified_elements,
+                                                                  include_only_classified_elements=include_only_classified_elements,
+                                                                  graph_query_depth=graph_query_depth,
+                                                                  governance_zone_filter=governance_zone_filter,
+                                                                  as_of_time=as_of_time,
+                                                                  effective_time=effective_time,
+                                                                  relationship_page_size=relationship_page_size,
+                                                                  limit_results_by_status=limit_results_by_status,
+                                                                  sequencing_order=sequencing_order,
+                                                                  sequencing_property=sequencing_property,
+                                                                  output_format=output_format,
+                                                                  report_spec=report_spec,
+                                                                  start_from=start_from,
+                                                                  page_size=page_size,
+                                                                  property_names=property_names,
+                                                                  body=body))
+
+    async def _async_get_glossaries_by_name(self, filter_string: Optional[str] = None, classification_names: Optional[list[str]] = None,
+                                             body: Optional[dict | FilterRequestBody] = None,
                                              start_from: int = 0, page_size: int = 0,
                                              output_format: str = 'JSON',
-                                             output_format_set: str | dict = None) -> dict | str:
-        return await self._async_get_collections_by_name(filter_string, classification_names, body, start_from, page_size, output_format, output_format_set)
+                                             report_spec: str | dict = None) -> dict | str:
+        return await self._async_get_collections_by_name(filter_string, classification_names, body, start_from, page_size, output_format, report_spec)
 
 
-    def get_glossaries_by_name(self, filter_string: str = None, classification_names: list[str] = None,
-                                             body: dict | FilterRequestBody = None,
+    def get_glossaries_by_name(self, filter_string: Optional[str] = None, classification_names: Optional[list[str]] = None,
+                                             body: Optional[dict | FilterRequestBody] = None,
                                              start_from: int = 0, page_size: int = 0,
                                              output_format: str = 'JSON',
-                                             output_format_set: str | dict = None) -> dict | str:
+                                             report_spec: str | dict = None) -> dict | str:
         loop = asyncio.get_event_loop()
         response = loop.run_until_complete(
             self._async_get_glossaries_by_name(filter_string, classification_names, body,start_from, page_size,
-                                               output_format, output_format_set))
+                                               output_format, report_spec))
         return response
 
-    async def _async_get_glossary_by_guid(self, glossary_guid: str, element_type: str = "Glossary", body: dict | GetRequestBody = None,
-                                          output_format: str = "JSON", output_format_set: str | dict = None) -> dict | str:
+    async def _async_get_glossary_by_guid(self, glossary_guid: str, element_type: str = "Glossary", body: Optional[dict | GetRequestBody] = None,
+                                          output_format: str = "JSON", report_spec: str | dict = None) -> dict | str:
 
-        return await self._async_get_collection_by_guid(glossary_guid, element_type, body, output_format, output_format_set)
+        return await self._async_get_collection_by_guid(glossary_guid, element_type, body, output_format, report_spec)
 
 
 
     def get_glossary_by_guid(self, glossary_guid: str, element_type: str = "Glossary", body: dict| GetRequestBody=None,
-                             output_format: str = "JSON", output_format_set: str | dict = None) -> dict | str:
+                             output_format: str = "JSON", report_spec: str | dict = None) -> dict | str:
         loop = asyncio.get_event_loop()
         response = loop.run_until_complete(
-            self._async_get_glossary_by_guid(glossary_guid, element_type, body,output_format, output_format_set))
+            self._async_get_glossary_by_guid(glossary_guid, element_type, body,output_format, report_spec))
         return response
 
 
 
-    async def _async_get_terms_by_name(self, filter_string: str = None, classification_names: list[str] = None,
-                                             body: dict | FilterRequestBody = None,
+    async def _async_get_terms_by_name(self, filter_string: Optional[str] = None, classification_names: Optional[list[str]] = None,
+                                             body: Optional[dict | FilterRequestBody] = None,
                                              start_from: int = 0, page_size: int = 0,
                                              output_format: str = 'JSON',
-                                             output_format_set: str | dict = None) -> list:
+                                             report_spec: str | dict = None) -> list:
         url = (f"{self.platform_url}/servers/{self.view_server}/api/open-metadata/glossary-manager/glossaries/"
                f"terms/by-name")
         response = await self._async_get_name_request(url, _type="GlossaryTerm",
@@ -2827,66 +2957,274 @@ class GlossaryManager(CollectionManager):
                                                       filter_string=filter_string,
                                                       classification_names=classification_names,
                                                       start_from=start_from, page_size=page_size,
-                                                      output_format=output_format, output_format_set=output_format_set,
+                                                      output_format=output_format, report_spec=report_spec,
                                                       body=body)
         return response
 
-    def get_terms_by_name(self, filter_string: str = None, classification_names: list[str] = None,
-                                             body: dict | FilterRequestBody = None,
+    def get_terms_by_name(self, filter_string: Optional[str] = None, classification_names: Optional[list[str]] = None,
+                                             body: Optional[dict | FilterRequestBody] = None,
                                              start_from: int = 0, page_size: int = 0,
                                              output_format: str = 'JSON',
-                                             output_format_set: str | dict = None) -> list:
+                                             report_spec: str | dict = None) -> list:
         loop = asyncio.get_event_loop()
         response = loop.run_until_complete(
             self._async_get_terms_by_name(filter_string, classification_names, body,start_from, page_size,
-                                           output_format, output_format_set))
+                                           output_format, report_spec))
         return response
 
     async def _async_get_term_by_guid(self, term_guid: str, element_type: str = "GlossaryTerm", body: dict| GetRequestBody=None,
-                             output_format: str = "JSON", output_format_set: str | dict = None) -> dict | str:
+                             output_format: str = "JSON", report_spec: str | dict = None) -> dict | str:
         url = (f"{self.platform_url}/servers/{self.view_server}/api/open-metadata/glossary-manager/glossaries/terms/"
                f"{term_guid}")
         response = await self._async_get_guid_request(url, _type=element_type,
                                                       _gen_output=self._generate_term_output,
-                                                      output_format=output_format, output_format_set=output_format_set,
+                                                      output_format=output_format, report_spec=report_spec,
                                                       body=body)
         return response
 
     def get_term_by_guid(self, term_guid: str, element_type: str = "GlossaryTerm", body: dict| GetRequestBody=None,
-                             output_format: str = "JSON", output_format_set: str | dict = None) -> dict | str:
+                             output_format: str = "JSON", report_spec: str | dict = None) -> dict | str:
         loop = asyncio.get_event_loop()
-        response = loop.run_until_complete(self._async_get_term_by_guid(term_guid, element_type, body,  output_format, output_format_set))
+        response = loop.run_until_complete(self._async_get_term_by_guid(term_guid, element_type, body,  output_format, report_spec))
         return response
 
-    async def _async_find_glossary_terms(self, search_string: str, starts_with: bool = False,
-                                     ends_with: bool = False, ignore_case: bool = False, type_name: str = "GlossaryTerm",
-                                     classification_names: list[str] = None, start_from: int = 0,
-                                     page_size: int = 0, output_format: str = 'JSON',
-                                     output_format_set: str | dict = None, body: dict = None) -> list | str:
+    @dynamic_catch
+    async def _async_find_glossary_terms(self, search_string: str = "*",
+                                         starts_with: bool = True, ends_with: bool = False,
+                                         ignore_case: bool = False,
+                                         anchor_domain: Optional[str] = None,
+                                         metadata_element_type: str = "GlossaryTerm",
+                                         metadata_element_subtypes: Optional[list[str]] = None,
+                                         skip_relationships: Optional[list[str]] = None,
+                                         include_only_relationships: Optional[list[str]] = None,
+                                         skip_classified_elements: Optional[list[str]] = None,
+                                         include_only_classified_elements: Optional[list[str]] = None,
+                                         graph_query_depth: int = 3,
+                                         governance_zone_filter: Optional[list[str]] = None, as_of_time: Optional[str] = None,
+                                         effective_time: Optional[str] = None, relationship_page_size: int = 0,
+                                         limit_results_by_status: Optional[list[str]] = None, sequencing_order: Optional[str] = None,
+                                         sequencing_property: Optional[str] = None,
+                                         output_format: str = "JSON",
+                                         report_spec: str | dict = "Glossary-Term-DrE",
+                                         start_from: int = 0, page_size: int = 100,
+                                         property_names: Optional[list[str]] = None,
+                                         body: Optional[dict | SearchStringRequestBody] = None) -> list | str:
+        """ Retrieve the list of glossary term metadata elements that contain the search string. Async Version.
+
+        Parameters
+        ----------
+        search_string: str
+            Search string to match against - None or '*' indicate match against all glossary terms.
+        starts_with : bool, [default=True], 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
+        anchor_domain: str, optional
+            The anchor domain to search in.
+        metadata_element_type: str, optional, [default="GlossaryTerm"]
+            The type of metadata element to search for.
+        metadata_element_subtypes: list[str], optional
+            The subtypes of metadata element to search for.
+        skip_relationships: list[str], optional
+            The types of relationships to skip.
+        include_only_relationships: list[str], optional
+            The types of relationships to include.
+        skip_classified_elements: list[str], optional
+            The types of classified elements to skip.
+        include_only_classified_elements: list[str], optional
+            The types of classified elements to include.
+        graph_query_depth: int, [default=3], optional
+            The depth of the graph query.
+        governance_zone_filter: list[str], optional
+            The governance zones to search in.
+        as_of_time: str, optional
+            The time to search as of.
+        effective_time: str, optional
+            The effective time to search at.
+        relationship_page_size: int, [default=0], optional
+            The page size for relationships.
+        limit_results_by_status: list[str], optional
+            The statuses to limit results by.
+        sequencing_order: str, optional
+            The order to sequence results by.
+        sequencing_property: str, optional
+            The property to sequence results by.
+        output_format: str, default = "JSON"
+            - one of "MD", "LIST", "FORM", "REPORT", "DICT", "MERMAID" or "JSON"
+        report_spec: str | dict , optional, default = "Glossary-Term-DrE"
+            - The desired output columns/fields to include.
+        start_from: int, [default=0], optional
+            When multiple pages of results are available, the page number to start from.
+        page_size: int, [default=100]
+            The number of items to return in a single page.
+        property_names: list[str], optional
+            The names of properties to search for.
+        body: dict | SearchStringRequestBody, optional, default = None
+            - if provided, the search parameters in the body will supercede other attributes, such as "search_string"
+
+        Returns
+        -------
+        List | str
+
+        Output depends on the output format specified.
+
+        Raises
+        ------
+
+        ValidationError
+          If the client passes incorrect parameters on the request that don't conform to the data model.
+        PyegeriaException
+          Issues raised in communicating or server side processing.
+        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-manager/glossaries/terms/"
                f"by-search-string")
-        response = await self._async_find_request(url, _type= type_name,
-                                                  _gen_output=self._generate_term_output,
-                                                  search_string = search_string, classification_names = classification_names,
-                                                  metadata_element_types = ["GlossaryTerm"],
-                                                  starts_with = starts_with, ends_with = ends_with, ignore_case = ignore_case,
-                                                  start_from = start_from, page_size = page_size,
-                                                  output_format=output_format, output_format_set=output_format_set,
-                                                  body=body)
+        response = await self._async_find_request(url, _type=metadata_element_type, _gen_output=self._generate_term_output,
+                                                  search_string=search_string, starts_with=starts_with,
+                                                  ends_with=ends_with, ignore_case=ignore_case,
+                                                  anchor_domain=anchor_domain,
+                                                  metadata_element_type=metadata_element_type,
+                                                  metadata_element_subtypes=metadata_element_subtypes,
+                                                  skip_relationships=skip_relationships,
+                                                  include_only_relationships=include_only_relationships,
+                                                  skip_classified_elements=skip_classified_elements,
+                                                  include_only_classified_elements=include_only_classified_elements,
+                                                  graph_query_depth=graph_query_depth,
+                                                  governance_zone_filter=governance_zone_filter,
+                                                  as_of_time=as_of_time, effective_time=effective_time,
+                                                  relationship_page_size=relationship_page_size,
+                                                  limit_results_by_status=limit_results_by_status,
+                                                  sequencing_order=sequencing_order,
+                                                  sequencing_property=sequencing_property,
+                                                  output_format=output_format, report_spec=report_spec,
+                                                  start_from=start_from, page_size=page_size,
+                                                  property_names=property_names, body=body)
+
         return response
 
-    def find_glossary_terms(self, search_string: str, starts_with: bool = False,
-                                     ends_with: bool = False, ignore_case: bool = False, type_name: str = "GlossaryTerm",
-                                     classification_names: list[str] = None, start_from: int = 0,
-                                     page_size: int = 0, output_format: str = 'JSON',
-                                     output_format_set: str | dict = None, body: dict = None) -> list | str:
+    @dynamic_catch
+    def find_glossary_terms(self, search_string: str = "*",
+                            starts_with: bool = True, ends_with: bool = False,
+                            ignore_case: bool = False,
+                            anchor_domain: Optional[str] = None,
+                            metadata_element_type: str = "GlossaryTerm",
+                            metadata_element_subtypes: Optional[list[str]] = None,
+                            skip_relationships: Optional[list[str]] = None,
+                            include_only_relationships: Optional[list[str]] = None,
+                            skip_classified_elements: Optional[list[str]] = None,
+                            include_only_classified_elements: Optional[list[str]] = None,
+                            graph_query_depth: int = 3,
+                            governance_zone_filter: Optional[list[str]] = None, as_of_time: Optional[str] = None,
+                            effective_time: Optional[str] = None, relationship_page_size: int = 0,
+                            limit_results_by_status: Optional[list[str]] = None, sequencing_order: Optional[str] = None,
+                            sequencing_property: Optional[str] = None,
+                            output_format: str = "JSON",
+                            report_spec: str | dict = "Glossary-Term-DrE",
+                            start_from: int = 0, page_size: int = 100,
+                            property_names: Optional[list[str]] = None,
+                            body: Optional[dict | SearchStringRequestBody] = None) -> list | str:
+        """ Retrieve the list of glossary term metadata elements that contain the search string.
+
+        Parameters
+        ----------
+        search_string: str
+            Search string to match against - None or '*' indicate match against all glossary terms.
+        starts_with : bool, [default=True], 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
+        anchor_domain: str, optional
+            The anchor domain to search in.
+        metadata_element_type: str, optional, [default="GlossaryTerm"]
+            The type of metadata element to search for.
+        metadata_element_subtypes: list[str], optional
+            The subtypes of metadata element to search for.
+        skip_relationships: list[str], optional
+            The types of relationships to skip.
+        include_only_relationships: list[str], optional
+            The types of relationships to include.
+        skip_classified_elements: list[str], optional
+            The types of classified elements to skip.
+        include_only_classified_elements: list[str], optional
+            The types of classified elements to include.
+        graph_query_depth: int, [default=3], optional
+            The depth of the graph query.
+        governance_zone_filter: list[str], optional
+            The governance zones to search in.
+        as_of_time: str, optional
+            The time to search as of.
+        effective_time: str, optional
+            The effective time to search at.
+        relationship_page_size: int, [default=0], optional
+            The page size for relationships.
+        limit_results_by_status: list[str], optional
+            The statuses to limit results by.
+        sequencing_order: str, optional
+            The order to sequence results by.
+        sequencing_property: str, optional
+            The property to sequence results by.
+        output_format: str, default = "JSON"
+            - one of "MD", "LIST", "FORM", "REPORT", "DICT", "MERMAID" or "JSON"
+        report_spec: str | dict , optional, default = "Glossary-Term-DrE"
+            - The desired output columns/fields to include.
+        start_from: int, [default=0], optional
+            When multiple pages of results are available, the page number to start from.
+        page_size: int, [default=100]
+            The number of items to return in a single page.
+        property_names: list[str], optional
+            The names of properties to search for.
+        body: dict | SearchStringRequestBody, optional, default = None
+            - if provided, the search parameters in the body will supercede other attributes, such as "search_string"
+
+        Returns
+-------
+        List | str
+
+        Output depends on the output format specified.
+
+        Raises
+-------
+
+        ValidationError
+          If the client passes incorrect parameters on the request that don't conform to the data model.
+        PyegeriaException
+          Issues raised in communicating or server side processing.
+        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_glossary_terms(search_string, starts_with,
-                                            ends_with, ignore_case, type_name,classification_names,
-                                            start_from,
-                                            page_size, output_format, output_format_set, body))
-        return response
+        return loop.run_until_complete(self._async_find_glossary_terms(search_string=search_string,
+                                                                      starts_with=starts_with,
+                                                                      ends_with=ends_with,
+                                                                      ignore_case=ignore_case,
+                                                                      anchor_domain=anchor_domain,
+                                                                      metadata_element_type=metadata_element_type,
+                                                                      metadata_element_subtypes=metadata_element_subtypes,
+                                                                      skip_relationships=skip_relationships,
+                                                                      include_only_relationships=include_only_relationships,
+                                                                      skip_classified_elements=skip_classified_elements,
+                                                                      include_only_classified_elements=include_only_classified_elements,
+                                                                      graph_query_depth=graph_query_depth,
+                                                                      governance_zone_filter=governance_zone_filter,
+                                                                      as_of_time=as_of_time,
+                                                                      effective_time=effective_time,
+                                                                      relationship_page_size=relationship_page_size,
+                                                                      limit_results_by_status=limit_results_by_status,
+                                                                      sequencing_order=sequencing_order,
+                                                                      sequencing_property=sequencing_property,
+                                                                      output_format=output_format,
+                                                                      report_spec=report_spec,
+                                                                      start_from=start_from,
+                                                                      page_size=page_size,
+                                                                      property_names=property_names,
+                                                                      body=body))
 
 
 if __name__ == "__main__":