pyegeria 0.7.45__py3-none-any.whl → 0.8.0__py3-none-any.whl

pyegeria/glossary_browser_omvs.py

@@ -11,7 +11,11 @@ from datetime import datetime
 
 # import json
 from pyegeria._client import Client
-from pyegeria._validators import (validate_name, validate_guid, validate_search_string, )
+from pyegeria._validators import (
+    validate_name,
+    validate_guid,
+    validate_search_string,
+)
 from pyegeria.utils import body_slimmer
 
 
@@ -32,19 +36,26 @@ class GlossaryBrowser(Client):
         user_pwd: str
             The password associated with the user_id. Defaults to None
 
-     """
+    """
 
-    def __init__(self, server_name: str, platform_url: str, token: str = None, user_id: str = None,
-                 user_pwd: str = None,  sync_mode: bool = True):
+    def __init__(
+        self,
+        server_name: str,
+        platform_url: str,
+        token: str = None,
+        user_id: str = None,
+        user_pwd: str = None,
+        sync_mode: bool = True,
+    ):
         self.admin_command_root: str
-        Client.__init__(self, server_name, platform_url, user_id=user_id, token=token, async_mode=sync_mode)
+        Client.__init__(self, server_name, platform_url, user_id=user_id, token=token)
 
     #
     #       Get Valid Values for Enumerations
     #
 
     async def _async_get_glossary_term_statuses(self, server_name: str = None) -> [str]:
-        """ Return the list of glossary term status enum values. Async version.
+        """Return the list of glossary term status enum values. Async version.
 
         Parameters
         ----------
@@ -60,14 +71,16 @@ class GlossaryBrowser(Client):
         if server_name is None:
             server_name = self.server_name
 
-        url = (f"{self.platform_url}/servers/{server_name}"
-               f"/api/open-metadata/glossary-browser/glossaries/terms/status-list")
+        url = (
+            f"{self.platform_url}/servers/{server_name}"
+            f"/api/open-metadata/glossary-browser/glossaries/terms/status-list"
+        )
 
         response = await self._async_make_request("GET", url)
         return response.json().get("statuses", [])
 
     def get_glossary_term_statuses(self, server_name: str = None) -> [str]:
-        """ Return the list of glossary term status enum values.
+        """Return the list of glossary term status enum values.
 
         Parameters
         ----------
@@ -81,11 +94,15 @@ class GlossaryBrowser(Client):
 
         """
         loop = asyncio.get_event_loop()
-        response = loop.run_until_complete(self._async_get_glossary_term_statuses(server_name))
+        response = loop.run_until_complete(
+            self._async_get_glossary_term_statuses(server_name)
+        )
         return response
 
-    async def _async_get_glossary_term_rel_statuses(self, server_name: str = None) -> [str]:
-        """ Return the list of glossary term relationship status enum values.  These values are stored in a
+    async def _async_get_glossary_term_rel_statuses(
+        self, server_name: str = None
+    ) -> [str]:
+        """Return the list of glossary term relationship status enum values.  These values are stored in a
         term-to-term, or term-to-category, relationship and are used to indicate how much the relationship should be
         trusted. Async version.
 
@@ -103,14 +120,16 @@ class GlossaryBrowser(Client):
         if server_name is None:
             server_name = self.server_name
 
-        url = (f"{self.platform_url}/servers/{server_name}"
-               f"/api/open-metadata/glossary-browser/glossaries/terms/relationships/status-list")
+        url = (
+            f"{self.platform_url}/servers/{server_name}"
+            f"/api/open-metadata/glossary-browser/glossaries/terms/relationships/status-list"
+        )
 
         response = await self._async_make_request("GET", url)
         return response.json().get("statuses", [])
 
     def get_glossary_term_rel_statuses(self, server_name: str = None) -> [str]:
-        """ Return the list of glossary term relationship status enum values.  These values are stored in a
+        """Return the list of glossary term relationship status enum values.  These values are stored in a
         term-to-term, or term-to-category, relationship and are used to indicate how much the relationship should be
         trusted.
 
@@ -126,11 +145,15 @@ class GlossaryBrowser(Client):
 
         """
         loop = asyncio.get_event_loop()
-        response = loop.run_until_complete(self._async_get_glossary_term_rel_statuses(server_name))
+        response = loop.run_until_complete(
+            self._async_get_glossary_term_rel_statuses(server_name)
+        )
         return response
 
-    async def _async_get_glossary_term_activity_types(self, server_name: str = None) -> [str]:
-        """ Return the list of glossary term activity type enum values. Async version.
+    async def _async_get_glossary_term_activity_types(
+        self, server_name: str = None
+    ) -> [str]:
+        """Return the list of glossary term activity type enum values. Async version.
 
         Parameters
         ----------
@@ -146,14 +169,16 @@ class GlossaryBrowser(Client):
         if server_name is None:
             server_name = self.server_name
 
-        url = (f"{self.platform_url}/servers/{server_name}"
-               f"/api/open-metadata/glossary-browser/glossaries/terms/activity-types")
+        url = (
+            f"{self.platform_url}/servers/{server_name}"
+            f"/api/open-metadata/glossary-browser/glossaries/terms/activity-types"
+        )
 
         response = await self._async_make_request("GET", url)
         return response.json().get("types", [])
 
     def get_glossary_term_activity_types(self, server_name: str = None) -> [str]:
-        """ Return the list of glossary term activity type enum values.
+        """Return the list of glossary term activity type enum values.
 
         Parameters
         ----------
@@ -167,18 +192,30 @@ class GlossaryBrowser(Client):
 
         """
         loop = asyncio.get_event_loop()
-        response = loop.run_until_complete(self._async_get_glossary_term_statuses(server_name))
+        response = loop.run_until_complete(
+            self._async_get_glossary_term_statuses(server_name)
+        )
         return response
 
     #
     #       Glossaries
     #
 
-    async def _async_find_glossaries(self, search_string: str, effective_time: str = None, starts_with: bool = False,
-                                     ends_with: bool = False, ignore_case: bool = False, for_lineage: bool = False,
-                                     for_duplicate_processing: bool = False, type_name: str = None,
-                                     server_name: str = None, start_from: int = 0, page_size: int = None) -> list | str:
-        """ Retrieve the list of glossary metadata elements that contain the search string. Async version.
+    async def _async_find_glossaries(
+        self,
+        search_string: str,
+        effective_time: str = None,
+        starts_with: bool = False,
+        ends_with: bool = False,
+        ignore_case: bool = False,
+        for_lineage: bool = False,
+        for_duplicate_processing: bool = False,
+        type_name: str = None,
+        server_name: str = None,
+        start_from: int = 0,
+        page_size: int = None,
+    ) -> list | str:
+        """Retrieve the list of glossary metadata elements that contain the search string. Async version.
             The search string is located in the request body and is interpreted as a plain string.
             The request parameters, startsWith, endsWith and ignoreCase can be used to allow a fuzzy search.
 
@@ -239,86 +276,115 @@ class GlossaryBrowser(Client):
 
         validate_search_string(search_string)
 
-        if search_string == '*':
+        if search_string == "*":
             search_string = None
 
-        body = {"class": "SearchStringRequestBody", "searchString": search_string, "effectiveTime": effective_time,
-                "typeName": type_name}
+        body = {
+            "class": "SearchStringRequestBody",
+            "searchString": search_string,
+            "effectiveTime": effective_time,
+            "typeName": type_name,
+        }
         body = body_slimmer(body)
         # print(f"\n\nBody is: \n{body}")
 
-        url = (f"{self.platform_url}/servers/{server_name}/api/open-metadata/glossary-browser/glossaries/"
-               f"by-search-string?startFrom={start_from}&pageSize={page_size}&startsWith={starts_with_s}&"
-               f"endsWith={ends_with_s}&ignoreCase={ignore_case_s}&forLineage={for_lineage_s}&"
-               f"forDuplicateProcessing={for_duplicate_processing_s}")
+        url = (
+            f"{self.platform_url}/servers/{server_name}/api/open-metadata/glossary-browser/glossaries/"
+            f"by-search-string?startFrom={start_from}&pageSize={page_size}&startsWith={starts_with_s}&"
+            f"endsWith={ends_with_s}&ignoreCase={ignore_case_s}&forLineage={for_lineage_s}&"
+            f"forDuplicateProcessing={for_duplicate_processing_s}"
+        )
 
         response = await self._async_make_request("POST", url, body)
         return response.json().get("elementList", "No Glossaries found")
 
-    def find_glossaries(self, search_string: str, effective_time: str = None, starts_with: bool = False,
-                        ends_with: bool = False, ignore_case: bool = False, for_lineage: bool = False,
-                        for_duplicate_processing: bool = False, type_name: str = None, server_name: str = None,
-                        start_from: int = 0, page_size: int = None) -> list | str:
-        """ Retrieve the list of glossary metadata elements that contain the search string.
-                   The search string is located in the request body and is interpreted as a plain string.
-                   The request parameters, startsWith, endsWith and ignoreCase can be used to allow a fuzzy search.
-
-           Parameters
-           ----------
-           search_string: str,
-               Search string to use to find matching glossaries. If the search string is '*',
-               then all glossaries returned.
-
-           effective_time: str, [default=None], optional
-               Effective time of the query. If not specified will default to any time. Time format is
-               "YYYY-MM-DDTHH:MM:SS" (ISO 8601)
-           server_name : str, optional
-               The name of the server to  configure.
-               If not provided, the server name associated with the instance is used.
-           starts_with : bool, [default=False], optional
-               Starts with the supplied string.
-           ends_with : bool, [default=False], optional
-               Ends with the supplied string
-           ignore_case : bool, [default=False], optional
-               Ignore case when searching
-           for_lineage : bool, [default=False], optional
-                Indicates the search is for lineage.
-           for_duplicate_processing : bool, [default=False], optional
-           type_name: str, [default=None], optional
-               An optional parameter indicating the subtype of the glossary to filter by.
-               Values include 'ControlledGlossary', 'EditingGlossary', and 'StagingGlossary'
-            start_from: int, [default=0], optional
-                When multiple pages of results are available, the page number to start from.
-            page_size: int, [default=None]
-                The number of items to return in a single page. If not specified, the default will be taken from
-                the class instance.
-           Returns
-           -------
-           List | str
-
-           A list of glossary definitions active in the server.
-
-           Raises
-           ------
-
-           InvalidParameterException
-             If the client passes incorrect parameters on the request - such as bad URLs or invalid values
-           PropertyServerException
-             Raised by the server when an issue arises in processing a valid request
-           NotAuthorizedException
-             The principle specified by the user_id does not have authorization for the requested action
-
-           """
+    def find_glossaries(
+        self,
+        search_string: str,
+        effective_time: str = None,
+        starts_with: bool = False,
+        ends_with: bool = False,
+        ignore_case: bool = False,
+        for_lineage: bool = False,
+        for_duplicate_processing: bool = False,
+        type_name: str = None,
+        server_name: str = None,
+        start_from: int = 0,
+        page_size: int = None,
+    ) -> list | str:
+        """Retrieve the list of glossary metadata elements that contain the search string.
+                The search string is located in the request body and is interpreted as a plain string.
+                The request parameters, startsWith, endsWith and ignoreCase can be used to allow a fuzzy search.
+
+        Parameters
+        ----------
+        search_string: str,
+            Search string to use to find matching glossaries. If the search string is '*',
+            then all glossaries returned.
+
+        effective_time: str, [default=None], optional
+            Effective time of the query. If not specified will default to any time. Time format is
+            "YYYY-MM-DDTHH:MM:SS" (ISO 8601)
+        server_name : str, optional
+            The name of the server to  configure.
+            If not provided, the server name associated with the instance is used.
+        starts_with : bool, [default=False], optional
+            Starts with the supplied string.
+        ends_with : bool, [default=False], optional
+            Ends with the supplied string
+        ignore_case : bool, [default=False], optional
+            Ignore case when searching
+        for_lineage : bool, [default=False], optional
+             Indicates the search is for lineage.
+        for_duplicate_processing : bool, [default=False], optional
+        type_name: str, [default=None], optional
+            An optional parameter indicating the subtype of the glossary to filter by.
+            Values include 'ControlledGlossary', 'EditingGlossary', and 'StagingGlossary'
+         start_from: int, [default=0], optional
+             When multiple pages of results are available, the page number to start from.
+         page_size: int, [default=None]
+             The number of items to return in a single page. If not specified, the default will be taken from
+             the class instance.
+        Returns
+        -------
+        List | str
+
+        A list of glossary definitions active in the server.
+
+        Raises
+        ------
+
+        InvalidParameterException
+          If the client passes incorrect parameters on the request - such as bad URLs or invalid values
+        PropertyServerException
+          Raised by the server when an issue arises in processing a valid request
+        NotAuthorizedException
+          The principle specified by the user_id does not have authorization for the requested action
+
+        """
         loop = asyncio.get_event_loop()
         response = loop.run_until_complete(
-            self._async_find_glossaries(search_string, effective_time, starts_with, ends_with, ignore_case, for_lineage,
-                                        for_duplicate_processing, type_name, server_name, start_from, page_size))
+            self._async_find_glossaries(
+                search_string,
+                effective_time,
+                starts_with,
+                ends_with,
+                ignore_case,
+                for_lineage,
+                for_duplicate_processing,
+                type_name,
+                server_name,
+                start_from,
+                page_size,
+            )
+        )
 
         return response
 
-    async def _async_get_glossary_by_guid(self, glossary_guid: str, server_name: str = None,
-                                          effective_time: str = None) -> dict:
-        """ Retrieves information about a glossary
+    async def _async_get_glossary_by_guid(
+        self, glossary_guid: str, server_name: str = None, effective_time: str = None
+    ) -> dict:
+        """Retrieves information about a glossary
         Parameters
         ----------
             glossary_guid : str
@@ -349,16 +415,21 @@ class GlossaryBrowser(Client):
             server_name = self.server_name
         validate_guid(glossary_guid)
 
-        body = {"class": "EffectiveTimeQueryRequestBody", "effectiveTime": effective_time}
+        body = {
+            "class": "EffectiveTimeQueryRequestBody",
+            "effectiveTime": effective_time,
+        }
 
-        url = (f"{self.platform_url}/servers/{server_name}/api/open-metadata/glossary-browser/glossaries/"
-               f"{glossary_guid}/retrieve")
+        url = (
+            f"{self.platform_url}/servers/{server_name}/api/open-metadata/glossary-browser/glossaries/"
+            f"{glossary_guid}/retrieve"
+        )
         print(url)
         response = await self._async_make_request("POST", url, payload=body)
         return response.json()
 
     def get_glossary_by_guid(self, glossary_guid: str, server_name: str = None) -> dict:
-        """ Retrieves information about a glossary
+        """Retrieves information about a glossary
         Parameters
         ----------
             glossary_guid : str
@@ -383,13 +454,20 @@ class GlossaryBrowser(Client):
         -----
         """
         loop = asyncio.get_event_loop()
-        response = loop.run_until_complete(self._async_get_glossary_by_guid(glossary_guid, server_name))
+        response = loop.run_until_complete(
+            self._async_get_glossary_by_guid(glossary_guid, server_name)
+        )
         return response
 
-    async def _async_get_glossaries_by_name(self, glossary_name: str, effective_time: str = None,
-                                            server_name: str = None, start_from: int = 0,
-                                            page_size: int = None) -> dict | str:
-        """ Retrieve the list of glossary metadata elements with an exactly matching qualified or display name.
+    async def _async_get_glossaries_by_name(
+        self,
+        glossary_name: str,
+        effective_time: str = None,
+        server_name: str = None,
+        start_from: int = 0,
+        page_size: int = None,
+    ) -> dict | str:
+        """Retrieve the list of glossary metadata elements with an exactly matching qualified or display name.
             There are no wildcards supported on this request.
 
         Parameters
@@ -436,15 +514,23 @@ class GlossaryBrowser(Client):
         else:
             body = {"name": glossary_name, "effectiveTime": effective_time}
 
-        url = (f"{self.platform_url}/servers/{server_name}/api/open-metadata/glossary-browser/glossaries/"
-               f"by-name?startFrom={start_from}&pageSize={page_size}")
+        url = (
+            f"{self.platform_url}/servers/{server_name}/api/open-metadata/glossary-browser/glossaries/"
+            f"by-name?startFrom={start_from}&pageSize={page_size}"
+        )
 
         response = await self._async_make_request("POST", url, body)
         return response.json()
 
-    def get_glossaries_by_name(self, glossary_name: str, effective_time: str = None, server_name: str = None,
-                               start_from: int = 0, page_size: int = None) -> dict | str:
-        """ Retrieve the list of glossary metadata elements with an exactly matching qualified or display name.
+    def get_glossaries_by_name(
+        self,
+        glossary_name: str,
+        effective_time: str = None,
+        server_name: str = None,
+        start_from: int = 0,
+        page_size: int = None,
+    ) -> dict | str:
+        """Retrieve the list of glossary metadata elements with an exactly matching qualified or display name.
             There are no wildcards supported on this request.
 
         Parameters
@@ -480,16 +566,23 @@ class GlossaryBrowser(Client):
         """
         loop = asyncio.get_event_loop()
         response = loop.run_until_complete(
-            self._async_get_glossaries_by_name(glossary_name, effective_time, server_name, start_from, page_size))
+            self._async_get_glossaries_by_name(
+                glossary_name, effective_time, server_name, start_from, page_size
+            )
+        )
         return response
 
     #
     # Glossary Categories
     #
 
-    async def _async_get_glossary_for_category(self, glossary_category_guid: str, effective_time: str = None,
-                                               server_name: str = None) -> dict | str:
-        """ Retrieve the glossary metadata element for the requested category.  The optional request body allows you to
+    async def _async_get_glossary_for_category(
+        self,
+        glossary_category_guid: str,
+        effective_time: str = None,
+        server_name: str = None,
+    ) -> dict | str:
+        """Retrieve the glossary metadata element for the requested category.  The optional request body allows you to
         specify that the glossary element should only be returned if it was effective at a particular time.
 
         Parameters
@@ -523,17 +616,26 @@ class GlossaryBrowser(Client):
         if server_name is None:
             server_name = self.server_name
 
-        body = {"class": "EffectiveTimeQueryRequestBody", "effectiveTime": effective_time}
+        body = {
+            "class": "EffectiveTimeQueryRequestBody",
+            "effectiveTime": effective_time,
+        }
 
-        url = (f"{self.platform_url}/servers/{server_name}/api/open-metadata/glossary-browser/glossaries/"
-               f"for-category/{glossary_category_guid}/retrieve")
+        url = (
+            f"{self.platform_url}/servers/{server_name}/api/open-metadata/glossary-browser/glossaries/"
+            f"for-category/{glossary_category_guid}/retrieve"
+        )
 
         response = await self._async_make_request("POST", url, body)
         return response.json()
 
-    def get_glossary_for_category(self, glossary_category_guid: str, effective_time: str = None,
-                                  server_name: str = None) -> dict | str:
-        """ Retrieve the glossary metadata element for the requested category.  The optional request body allows you to
+    def get_glossary_for_category(
+        self,
+        glossary_category_guid: str,
+        effective_time: str = None,
+        server_name: str = None,
+    ) -> dict | str:
+        """Retrieve the glossary metadata element for the requested category.  The optional request body allows you to
         specify that the glossary element should only be returned if it was effective at a particular time.
 
         Parameters
@@ -566,14 +668,24 @@ class GlossaryBrowser(Client):
         """
         loop = asyncio.get_event_loop()
         response = loop.run_until_complete(
-            self._async_get_glossary_for_category(glossary_category_guid, effective_time, server_name))
+            self._async_get_glossary_for_category(
+                glossary_category_guid, effective_time, server_name
+            )
+        )
         return response
 
-    async def _async_find_glossary_categories(self, search_string: str, effective_time: str = None,
-                                              starts_with: bool = False, ends_with: bool = False,
-                                              ignore_case: bool = False, server_name: str = None, start_from: int = 0,
-                                              page_size: int = None) -> list | str:
-        """ Retrieve the list of glossary category metadata elements that contain the search string.
+    async def _async_find_glossary_categories(
+        self,
+        search_string: str,
+        effective_time: str = None,
+        starts_with: bool = False,
+        ends_with: bool = False,
+        ignore_case: bool = False,
+        server_name: str = None,
+        start_from: int = 0,
+        page_size: int = None,
+    ) -> list | str:
+        """Retrieve the list of glossary category metadata elements that contain the search string.
             The search string is located in the request body and is interpreted as a plain string.
             The request parameters, startsWith, endsWith and ignoreCase can be used to allow a fuzzy search.
             Async version.
@@ -627,76 +739,104 @@ class GlossaryBrowser(Client):
 
         validate_search_string(search_string)
 
-        if search_string == '*':
+        if search_string == "*":
             search_string = None
 
-        body = {"class": "SearchStringRequestBody", "searchString": search_string, "effectiveTime": effective_time}
+        body = {
+            "class": "SearchStringRequestBody",
+            "searchString": search_string,
+            "effectiveTime": effective_time,
+        }
         body = body_slimmer(body)
 
-        url = (f"{self.platform_url}/servers/{server_name}/api/open-metadata/glossary-browser/glossaries/"
-               f"categories/by-search-string?startFrom={start_from}&pageSize={page_size}&startsWith={starts_with_s}&"
-               f"endsWith={ends_with_s}&ignoreCase={ignore_case_s}")
+        url = (
+            f"{self.platform_url}/servers/{server_name}/api/open-metadata/glossary-browser/glossaries/"
+            f"categories/by-search-string?startFrom={start_from}&pageSize={page_size}&startsWith={starts_with_s}&"
+            f"endsWith={ends_with_s}&ignoreCase={ignore_case_s}"
+        )
 
         response = await self._async_make_request("POST", url, body)
         return response.json().get("elementList", "No Categories found")
 
-    def find_glossary_categories(self, search_string: str, effective_time: str = None, starts_with: bool = False,
-                                 ends_with: bool = False, ignore_case: bool = False, server_name: str = None,
-                                 start_from: int = 0, page_size: int = None) -> list | str:
-        """ Retrieve the list of glossary category metadata elements that contain the search string.
-            The search string is located in the request body and is interpreted as a plain string.
-            The request parameters, startsWith, endsWith and ignoreCase can be used to allow a fuzzy search.
+    def find_glossary_categories(
+        self,
+        search_string: str,
+        effective_time: str = None,
+        starts_with: bool = False,
+        ends_with: bool = False,
+        ignore_case: bool = False,
+        server_name: str = None,
+        start_from: int = 0,
+        page_size: int = None,
+    ) -> list | str:
+        """Retrieve the list of glossary category metadata elements that contain the search string.
+         The search string is located in the request body and is interpreted as a plain string.
+         The request parameters, startsWith, endsWith and ignoreCase can be used to allow a fuzzy search.
 
-           Parameters
-           ----------
-           search_string: str,
-               Search string to use to find matching glossaries. If the search string is '*' then all
-                glossaries returned.
-
-           effective_time: str, [default=None], optional
-               Effective time of the query. If not specified will default to any time. Time format is
-               "YYYY-MM-DDTHH:MM:SS" (ISO 8601)
-           server_name : str, optional
-               The name of the server to  configure.
-               If not provided, the server name associated with the instance is used.
-           starts_with : bool, [default=False], optional
-               Starts with the supplied string.
-           ends_with : bool, [default=False], optional
-               Ends with the supplied string
-           ignore_case : bool, [default=False], optional
-               Ignore case when searching
-            start_from: int, [default=0], optional
-                When multiple pages of results are available, the page number to start from.
-            page_size: int, [default=None]
-                The number of items to return in a single page. If not specified, the default will be taken from
-                the class instance.
-           Returns
-           -------
-           List | str
-
-           A list of glossary definitions active in the server.
-
-           Raises
-           ------
-
-           InvalidParameterException
-             If the client passes incorrect parameters on the request - such as bad URLs or invalid values
-           PropertyServerException
-             Raised by the server when an issue arises in processing a valid request
-           NotAuthorizedException
-             The principle specified by the user_id does not have authorization for the requested action
-
-           """
+        Parameters
+        ----------
+        search_string: str,
+            Search string to use to find matching glossaries. If the search string is '*' then all
+             glossaries returned.
+
+        effective_time: str, [default=None], optional
+            Effective time of the query. If not specified will default to any time. Time format is
+            "YYYY-MM-DDTHH:MM:SS" (ISO 8601)
+        server_name : str, optional
+            The name of the server to  configure.
+            If not provided, the server name associated with the instance is used.
+        starts_with : bool, [default=False], optional
+            Starts with the supplied string.
+        ends_with : bool, [default=False], optional
+            Ends with the supplied string
+        ignore_case : bool, [default=False], optional
+            Ignore case when searching
+         start_from: int, [default=0], optional
+             When multiple pages of results are available, the page number to start from.
+         page_size: int, [default=None]
+             The number of items to return in a single page. If not specified, the default will be taken from
+             the class instance.
+        Returns
+        -------
+        List | str
+
+        A list of glossary definitions active in the server.
+
+        Raises
+        ------
+
+        InvalidParameterException
+          If the client passes incorrect parameters on the request - such as bad URLs or invalid values
+        PropertyServerException
+          Raised by the server when an issue arises in processing a valid request
+        NotAuthorizedException
+          The principle specified by the user_id does not have authorization for the requested action
+
+        """
         loop = asyncio.get_event_loop()
         response = loop.run_until_complete(
-            self._async_find_glossary_categories(search_string, effective_time, starts_with, ends_with, ignore_case,
-                                                 server_name, start_from, page_size))
+            self._async_find_glossary_categories(
+                search_string,
+                effective_time,
+                starts_with,
+                ends_with,
+                ignore_case,
+                server_name,
+                start_from,
+                page_size,
+            )
+        )
 
         return response
 
-    async def _async_get_categories_for_glossary(self, glossary_guid: str, server_name: str = None, start_from: int = 0,
-                                                 page_size: int = None) -> list | str:
-        """ Return the list of categories associated with a glossary.
+    async def _async_get_categories_for_glossary(
+        self,
+        glossary_guid: str,
+        server_name: str = None,
+        start_from: int = 0,
+        page_size: int = None,
+    ) -> list | str:
+        """Return the list of categories associated with a glossary.
             Async version.
 
         Parameters
@@ -733,15 +873,22 @@ class GlossaryBrowser(Client):
         if page_size is None:
             page_size = self.page_size
 
-        url = (f"{self.platform_url}/servers/{server_name}/api/open-metadata/glossary-browser/glossaries/"
-               f"{glossary_guid}/categories/retrieve?startFrom={start_from}&pageSize={page_size}")
+        url = (
+            f"{self.platform_url}/servers/{server_name}/api/open-metadata/glossary-browser/glossaries/"
+            f"{glossary_guid}/categories/retrieve?startFrom={start_from}&pageSize={page_size}"
+        )
 
         response = await self._async_make_request("POST", url)
         return response.json().get("elementList", "No Categories found")
 
-    def get_categories_for_glossary(self, glossary_guid: str, server_name: str = None, start_from: int = 0,
-                                    page_size: int = None) -> list | str:
-        """ Return the list of categories associated with a glossary.
+    def get_categories_for_glossary(
+        self,
+        glossary_guid: str,
+        server_name: str = None,
+        start_from: int = 0,
+        page_size: int = None,
+    ) -> list | str:
+        """Return the list of categories associated with a glossary.
 
         Parameters
         ----------
@@ -774,12 +921,20 @@ class GlossaryBrowser(Client):
         """
         loop = asyncio.get_event_loop()
         response = loop.run_until_complete(
-            self._async_get_categories_for_glossary(glossary_guid, server_name, start_from, page_size))
+            self._async_get_categories_for_glossary(
+                glossary_guid, server_name, start_from, page_size
+            )
+        )
         return response
 
-    async def _async_get_categories_for_term(self, glossary_term_guid: str, server_name: str = None,
-                                             start_from: int = 0, page_size: int = None) -> list | str:
-        """ Return the list of categories associated with a glossary term.
+    async def _async_get_categories_for_term(
+        self,
+        glossary_term_guid: str,
+        server_name: str = None,
+        start_from: int = 0,
+        page_size: int = None,
+    ) -> list | str:
+        """Return the list of categories associated with a glossary term.
             Async version.
 
         Parameters
@@ -816,15 +971,22 @@ class GlossaryBrowser(Client):
         if page_size is None:
             page_size = self.page_size
 
-        url = (f"{self.platform_url}/servers/{server_name}/api/open-metadata/glossary-browser/glossaries/terms/"
-               f"{glossary_term_guid}/categories/retrieve?startFrom={start_from}&pageSize={page_size}")
+        url = (
+            f"{self.platform_url}/servers/{server_name}/api/open-metadata/glossary-browser/glossaries/terms/"
+            f"{glossary_term_guid}/categories/retrieve?startFrom={start_from}&pageSize={page_size}"
+        )
 
         response = await self._async_make_request("POST", url)
         return response.json().get("elementList", "No Categories found")
 
-    def get_categories_for_term(self, glossary_term_guid: str, server_name: str = None, start_from: int = 0,
-                                page_size: int = None) -> list | str:
-        """ Return the list of categories associated with a glossary term.
+    def get_categories_for_term(
+        self,
+        glossary_term_guid: str,
+        server_name: str = None,
+        start_from: int = 0,
+        page_size: int = None,
+    ) -> list | str:
+        """Return the list of categories associated with a glossary term.
 
         Parameters
         ----------
@@ -857,13 +1019,22 @@ class GlossaryBrowser(Client):
         """
         loop = asyncio.get_event_loop()
         response = loop.run_until_complete(
-            self._async_get_categories_for_term(glossary_term_guid, server_name, start_from, page_size))
+            self._async_get_categories_for_term(
+                glossary_term_guid, server_name, start_from, page_size
+            )
+        )
         return response
 
-    async def _async_get_categories_by_name(self, name: str, glossary_guid: str = None, status: [str] = ["ACTIVE"],
-                                            server_name: str = None, start_from: int = 0,
-                                            page_size: int = None) -> list | str:
-        """ Retrieve the list of glossary category metadata elements that either have the requested qualified name or
+    async def _async_get_categories_by_name(
+        self,
+        name: str,
+        glossary_guid: str = None,
+        status: [str] = ["ACTIVE"],
+        server_name: str = None,
+        start_from: int = 0,
+        page_size: int = None,
+    ) -> list | str:
+        """Retrieve the list of glossary category metadata elements that either have the requested qualified name or
             display name. The name to search for is located in the request body and is interpreted as a plain string.
             The request body also supports the specification of a glossaryGUID to restrict the search to within a single
             glossary.
@@ -909,20 +1080,33 @@ class GlossaryBrowser(Client):
             page_size = self.page_size
         validate_name(name)
 
-        url = (f"{self.platform_url}/servers/{server_name}/api/open-metadata/glossary-browser/glossaries/categories/"
-               f"by-name?startFrom={start_from}&pageSize={page_size}")
+        url = (
+            f"{self.platform_url}/servers/{server_name}/api/open-metadata/glossary-browser/glossaries/categories/"
+            f"by-name?startFrom={start_from}&pageSize={page_size}"
+        )
 
-        body = {"class": "GlossaryNameRequestBody", "name": name, "glossaryGUID": glossary_guid,
-                "limitResultsByStatus": status}
+        body = {
+            "class": "GlossaryNameRequestBody",
+            "name": name,
+            "glossaryGUID": glossary_guid,
+            "limitResultsByStatus": status,
+        }
 
         response = await self._async_make_request("POST", url, body)
         return response.json().get("elementList", "No Categories found")
 
-    def get_categories_by_name(self, name: str, glossary_guid: str = None, status: [str] = ["ACTIVE"],
-                               server_name: str = None, start_from: int = 0, page_size: int = None) -> list | str:
-        """ Retrieve the list of glossary category metadata elements that either have the requested qualified name or 
+    def get_categories_by_name(
+        self,
+        name: str,
+        glossary_guid: str = None,
+        status: [str] = ["ACTIVE"],
+        server_name: str = None,
+        start_from: int = 0,
+        page_size: int = None,
+    ) -> list | str:
+        """Retrieve the list of glossary category metadata elements that either have the requested qualified name or
             display name. The name to search for is located in the request body and is interpreted as a plain string.
-            The request body also supports the specification of a glossaryGUID to restrict the search to within a 
+            The request body also supports the specification of a glossaryGUID to restrict the search to within a
             single glossary.
 
         Parameters
@@ -960,12 +1144,19 @@ class GlossaryBrowser(Client):
         """
         loop = asyncio.get_event_loop()
         response = loop.run_until_complete(
-            self._async_get_categories_by_name(name, glossary_guid, status, server_name, start_from, page_size))
+            self._async_get_categories_by_name(
+                name, glossary_guid, status, server_name, start_from, page_size
+            )
+        )
         return response
 
-    async def _async_get_categories_by_guid(self, glossary_category_guid: str, effective_time: str = None,
-                                            server_name: str = None) -> list | str:
-        """  Retrieve the requested glossary category metadata element.  The optional request body contain an effective
+    async def _async_get_categories_by_guid(
+        self,
+        glossary_category_guid: str,
+        effective_time: str = None,
+        server_name: str = None,
+    ) -> list | str:
+        """Retrieve the requested glossary category metadata element.  The optional request body contain an effective
         time for the query..
 
         Async version.
@@ -1001,17 +1192,26 @@ class GlossaryBrowser(Client):
         if server_name is None:
             server_name = self.server_name
 
-        url = (f"{self.platform_url}/servers/{server_name}/api/open-metadata/glossary-browser/glossaries/categories/"
-               f"{glossary_category_guid}/retrieve")
+        url = (
+            f"{self.platform_url}/servers/{server_name}/api/open-metadata/glossary-browser/glossaries/categories/"
+            f"{glossary_category_guid}/retrieve"
+        )
 
-        body = {"class": "EffectiveTimeQueryRequestBody", "effectiveTime": effective_time}
+        body = {
+            "class": "EffectiveTimeQueryRequestBody",
+            "effectiveTime": effective_time,
+        }
 
         response = await self._async_make_request("POST", url, body)
         return response.json().get("element", "No Category found")
 
-    def get_categories_by_guid(self, glossary_category_guid: str, effective_time: str = None,
-                               server_name: str = None) -> list | str:
-        """  Retrieve the requested glossary category metadata element.  The optional request body contain an effective
+    def get_categories_by_guid(
+        self,
+        glossary_category_guid: str,
+        effective_time: str = None,
+        server_name: str = None,
+    ) -> list | str:
+        """Retrieve the requested glossary category metadata element.  The optional request body contain an effective
         time for the query..
 
         Parameters
@@ -1044,12 +1244,19 @@ class GlossaryBrowser(Client):
         """
         loop = asyncio.get_event_loop()
         response = loop.run_until_complete(
-            self._async_get_categories_by_guid(glossary_category_guid, effective_time, server_name))
+            self._async_get_categories_by_guid(
+                glossary_category_guid, effective_time, server_name
+            )
+        )
         return response
 
-    async def _async_get_category_parent(self, glossary_category_guid: str, effective_time: str = None,
-                                         server_name: str = None) -> list | str:
-        """ Glossary categories can be organized in a hierarchy. Retrieve the parent glossary category metadata
+    async def _async_get_category_parent(
+        self,
+        glossary_category_guid: str,
+        effective_time: str = None,
+        server_name: str = None,
+    ) -> list | str:
+        """Glossary categories can be organized in a hierarchy. Retrieve the parent glossary category metadata
             element for the glossary category with the supplied unique identifier.  If the requested category
             does not have a parent category, null is returned.  The optional request body contain an effective time
             for the query.
@@ -1087,17 +1294,26 @@ class GlossaryBrowser(Client):
         if server_name is None:
             server_name = self.server_name
 
-        url = (f"{self.platform_url}/servers/{server_name}/api/open-metadata/glossary-browser/glossaries/categories/"
-               f"{glossary_category_guid}/parent/retrieve")
+        url = (
+            f"{self.platform_url}/servers/{server_name}/api/open-metadata/glossary-browser/glossaries/categories/"
+            f"{glossary_category_guid}/parent/retrieve"
+        )
 
-        body = {"class": "EffectiveTimeQueryRequestBody", "effectiveTime": effective_time}
+        body = {
+            "class": "EffectiveTimeQueryRequestBody",
+            "effectiveTime": effective_time,
+        }
 
         response = await self._async_make_request("POST", url, body)
         return response.json().get("element", "No Parent Category found")
 
-    def get_category_parent(self, glossary_category_guid: str, effective_time: str = None,
-                            server_name: str = None) -> list | str:
-        """ Glossary categories can be organized in a hierarchy. Retrieve the parent glossary category metadata
+    def get_category_parent(
+        self,
+        glossary_category_guid: str,
+        effective_time: str = None,
+        server_name: str = None,
+    ) -> list | str:
+        """Glossary categories can be organized in a hierarchy. Retrieve the parent glossary category metadata
             element for the glossary category with the supplied unique identifier.  If the requested category
             does not have a parent category, null is returned.  The optional request body contain an effective time
             for the query.
@@ -1132,17 +1348,25 @@ class GlossaryBrowser(Client):
         """
         loop = asyncio.get_event_loop()
         response = loop.run_until_complete(
-            self._async_get_category_parent(glossary_category_guid, effective_time, server_name))
+            self._async_get_category_parent(
+                glossary_category_guid, effective_time, server_name
+            )
+        )
         return response
 
     #
     #  Terms
     #
 
-    async def _async_get_terms_for_category(self, glossary_category_guid: str, server_name: str = None,
-                                            effective_time: str = None, start_from: int = 0,
-                                            page_size: int = None) -> list | str:
-        """ Retrieve ALL the glossary terms in a category.
+    async def _async_get_terms_for_category(
+        self,
+        glossary_category_guid: str,
+        server_name: str = None,
+        effective_time: str = None,
+        start_from: int = 0,
+        page_size: int = None,
+    ) -> list | str:
+        """Retrieve ALL the glossary terms in a category.
             The request body also supports the specification of an effective time for the query.
 
             Async Version.
@@ -1185,8 +1409,10 @@ class GlossaryBrowser(Client):
         if page_size is None:
             page_size = self.page_size
 
-        url = (f"{self.platform_url}/servers/{server_name}/api/open-metadata/glossary-browser/glossaries/terms/"
-               f"{glossary_category_guid}/terms/retrieve?startFrom={start_from}&pageSize={page_size}")
+        url = (
+            f"{self.platform_url}/servers/{server_name}/api/open-metadata/glossary-browser/glossaries/terms/"
+            f"{glossary_category_guid}/terms/retrieve?startFrom={start_from}&pageSize={page_size}"
+        )
 
         if effective_time is not None:
             body = {"effectiveTime": effective_time}
@@ -1196,10 +1422,15 @@ class GlossaryBrowser(Client):
 
         return response.json().get("elementList", "No terms found")
 
-    def get_terms_for_category(self, glossary_category_guid: str, server_name: str = None,
-                               effective_time: str = None, start_from: int = 0,
-                               page_size: int = None) -> list | str:
-        """ Retrieve ALL the glossary terms in a category.
+    def get_terms_for_category(
+        self,
+        glossary_category_guid: str,
+        server_name: str = None,
+        effective_time: str = None,
+        start_from: int = 0,
+        page_size: int = None,
+    ) -> list | str:
+        """Retrieve ALL the glossary terms in a category.
             The request body also supports the specification of an effective time for the query.
 
             Async Version.
@@ -1236,15 +1467,26 @@ class GlossaryBrowser(Client):
         """
         loop = asyncio.get_event_loop()
         response = loop.run_until_complete(
-            self._async_get_terms_for_category(glossary_category_guid, server_name, effective_time, start_from,
-                                               page_size))
+            self._async_get_terms_for_category(
+                glossary_category_guid,
+                server_name,
+                effective_time,
+                start_from,
+                page_size,
+            )
+        )
 
         return response
 
-    async def _async_get_terms_for_glossary(self, glossary_guid: str, server_name: str = None,
-                                            effective_time: str = None, start_from: int = 0,
-                                            page_size: int = None) -> list | str:
-        """ Retrieve the list of glossary terms associated with a glossary.
+    async def _async_get_terms_for_glossary(
+        self,
+        glossary_guid: str,
+        server_name: str = None,
+        effective_time: str = None,
+        start_from: int = 0,
+        page_size: int = None,
+    ) -> list | str:
+        """Retrieve the list of glossary terms associated with a glossary.
             The request body also supports the specification of an effective time for the query.
         Parameters
         ----------
@@ -1284,8 +1526,10 @@ class GlossaryBrowser(Client):
         if page_size is None:
             page_size = self.page_size
 
-        url = (f"{self.platform_url}/servers/{server_name}/api/open-metadata/glossary-browser/glossaries/"
-               f"{glossary_guid}/terms/retrieve?startFrom={start_from}&pageSize={page_size}")
+        url = (
+            f"{self.platform_url}/servers/{server_name}/api/open-metadata/glossary-browser/glossaries/"
+            f"{glossary_guid}/terms/retrieve?startFrom={start_from}&pageSize={page_size}"
+        )
 
         if effective_time is not None:
             body = {"effectiveTime": effective_time}
@@ -1295,9 +1539,15 @@ class GlossaryBrowser(Client):
 
         return response.json().get("elementList", "No terms found")
 
-    def get_terms_for_glossary(self, glossary_guid: str, server_name: str = None, effective_time: str = None,
-                               start_from: int = 0, page_size: int = None) -> list | str:
-        """ Retrieve the list of glossary terms associated with a glossary.
+    def get_terms_for_glossary(
+        self,
+        glossary_guid: str,
+        server_name: str = None,
+        effective_time: str = None,
+        start_from: int = 0,
+        page_size: int = None,
+    ) -> list | str:
+        """Retrieve the list of glossary terms associated with a glossary.
             The request body also supports the specification of an effective time for the query.
         Parameters
         ----------
@@ -1331,15 +1581,22 @@ class GlossaryBrowser(Client):
         """
         loop = asyncio.get_event_loop()
         response = loop.run_until_complete(
-            self._async_get_terms_for_glossary(glossary_guid, server_name, effective_time, start_from, page_size))
+            self._async_get_terms_for_glossary(
+                glossary_guid, server_name, effective_time, start_from, page_size
+            )
+        )
 
         return response
 
-    async def _async_get_term_relationships(self, term_guid: str, server_name: str = None,
-                                            effective_time: str = None, start_from: int = 0,
-                                            page_size: int = None) -> list | str:
-
-        """ This call retrieves details of the glossary terms linked to this glossary term.
+    async def _async_get_term_relationships(
+        self,
+        term_guid: str,
+        server_name: str = None,
+        effective_time: str = None,
+        start_from: int = 0,
+        page_size: int = None,
+    ) -> list | str:
+        """This call retrieves details of the glossary terms linked to this glossary term.
         Notice the original org 1 glossary term is linked via the "SourcedFrom" relationship..
         Parameters
         ----------
@@ -1379,8 +1636,10 @@ class GlossaryBrowser(Client):
         if page_size is None:
             page_size = self.page_size
 
-        url = (f"{self.platform_url}/servers/{server_name}/api/open-metadata/glossary-browser/glossaries/terms/"
-               f"{term_guid}/related-terms?startFrom={start_from}&pageSize={page_size}")
+        url = (
+            f"{self.platform_url}/servers/{server_name}/api/open-metadata/glossary-browser/glossaries/terms/"
+            f"{term_guid}/related-terms?startFrom={start_from}&pageSize={page_size}"
+        )
 
         if effective_time is not None:
             body = {"effectiveTime": effective_time}
@@ -1390,10 +1649,15 @@ class GlossaryBrowser(Client):
 
         return response.json().get("elementList", "No terms found")
 
-    def get_term_relationships(self, term_guid: str, server_name: str = None, effective_time: str = None,
-                               start_from: int = 0, page_size: int = None) -> list | str:
-
-        """ This call retrieves details of the glossary terms linked to this glossary term.
+    def get_term_relationships(
+        self,
+        term_guid: str,
+        server_name: str = None,
+        effective_time: str = None,
+        start_from: int = 0,
+        page_size: int = None,
+    ) -> list | str:
+        """This call retrieves details of the glossary terms linked to this glossary term.
         Notice the original org 1 glossary term is linked via the "SourcedFrom" relationship..
         Parameters
         ----------
@@ -1427,13 +1691,17 @@ class GlossaryBrowser(Client):
         """
         loop = asyncio.get_event_loop()
         response = loop.run_until_complete(
-            self._async_get_term_relationships(term_guid, server_name, effective_time, start_from, page_size))
+            self._async_get_term_relationships(
+                term_guid, server_name, effective_time, start_from, page_size
+            )
+        )
 
         return response
 
-    async def _async_get_glossary_for_term(self, term_guid: str, server_name: str = None,
-                                           effective_time: str = None) -> dict | str:
-        """ Retrieve the glossary metadata element for the requested term.  The optional request body allows you to 
+    async def _async_get_glossary_for_term(
+        self, term_guid: str, server_name: str = None, effective_time: str = None
+    ) -> dict | str:
+        """Retrieve the glossary metadata element for the requested term.  The optional request body allows you to
             specify that the glossary element should only be returned if it was effective at a particular time.
 
             Async Version.
@@ -1467,16 +1735,22 @@ class GlossaryBrowser(Client):
             server_name = self.server_name
         validate_guid(term_guid)
 
-        body = {"class": "EffectiveTimeQueryRequestBody", "effectiveTime": effective_time}
-        url = (f"{self.platform_url}/servers/{server_name}/api/open-metadata/glossary-browser/glossaries/"
-               f"for-term/{term_guid}/retrieve")
+        body = {
+            "class": "EffectiveTimeQueryRequestBody",
+            "effectiveTime": effective_time,
+        }
+        url = (
+            f"{self.platform_url}/servers/{server_name}/api/open-metadata/glossary-browser/glossaries/"
+            f"for-term/{term_guid}/retrieve"
+        )
 
         response = await self._async_make_request("POST", url, body)
         return response.json().get("element", "No glossary found")
 
-    def get_glossary_for_term(self, term_guid: str, server_name: str = None,
-                              effective_time: str = None) -> dict | str:
-        """ Retrieve the glossary metadata element for the requested term.  The optional request body allows you to 
+    def get_glossary_for_term(
+        self, term_guid: str, server_name: str = None, effective_time: str = None
+    ) -> dict | str:
+        """Retrieve the glossary metadata element for the requested term.  The optional request body allows you to
             specify that the glossary element should only be returned if it was effective at a particular time.
 
             Async Version.
@@ -1507,14 +1781,24 @@ class GlossaryBrowser(Client):
         -----
         """
         loop = asyncio.get_event_loop()
-        response = loop.run_until_complete(self._async_get_glossary_for_term(term_guid, server_name, effective_time))
+        response = loop.run_until_complete(
+            self._async_get_glossary_for_term(term_guid, server_name, effective_time)
+        )
         return response
 
-    async def _async_get_terms_by_name(self, term: str, glossary_guid: str = None, status_filter: list = [],
-                                       server_name: str = None, effective_time: str = None,
-                                       for_lineage: bool = False, for_duplicate_processing: bool = False,
-                                       start_from: int = 0, page_size: int = None) -> list:
-        """ Retrieve glossary terms by display name or qualified name. Async Version.
+    async def _async_get_terms_by_name(
+        self,
+        term: str,
+        glossary_guid: str = None,
+        status_filter: list = [],
+        server_name: str = None,
+        effective_time: str = None,
+        for_lineage: bool = False,
+        for_duplicate_processing: bool = False,
+        start_from: int = 0,
+        page_size: int = None,
+    ) -> list:
+        """Retrieve glossary terms by display name or qualified name. Async Version.
 
         Parameters
         ----------
@@ -1562,69 +1846,97 @@ class GlossaryBrowser(Client):
         for_lineage_s = str(for_lineage).lower()
         for_duplicate_processing_s = str(for_duplicate_processing).lower()
 
-        body = {"class": "GlossaryNameRequestBody", "glossaryGUID": glossary_guid, "name": term,
-                "effectiveTime": effective_time, "limitResultsByStatus": status_filter}
+        body = {
+            "class": "GlossaryNameRequestBody",
+            "glossaryGUID": glossary_guid,
+            "name": term,
+            "effectiveTime": effective_time,
+            "limitResultsByStatus": status_filter,
+        }
         # body = body_slimmer(body)
 
-        url = (f"{self.platform_url}/servers/{server_name}/api/open-metadata/glossary-browser/glossaries/"
-               f"terms/by-name?startFrom={start_from}&pageSize={page_size}&"
-               f"&forLineage={for_lineage_s}&forDuplicateProcessing={for_duplicate_processing_s}")
+        url = (
+            f"{self.platform_url}/servers/{server_name}/api/open-metadata/glossary-browser/glossaries/"
+            f"terms/by-name?startFrom={start_from}&pageSize={page_size}&"
+            f"&forLineage={for_lineage_s}&forDuplicateProcessing={for_duplicate_processing_s}"
+        )
 
         # print(f"\n\nURL is: \n {url}\n\nBody is: \n{body}")
 
         response = await self._async_make_request("POST", url, body)
         return response.json().get("elementList", "No terms found")
 
-    def get_terms_by_name(self, term: str, glossary_guid: str = None, status_filter: list = [], server_name: str = None,
-                          effective_time: str = None, for_lineage: bool = False,
-                          for_duplicate_processing: bool = False, start_from: int = 0, page_size: int = None) -> list:
-        """ Retrieve glossary terms by display name or qualified name.
-
-           Parameters
-           ----------
-           term : str
-               The term to search for in the glossaries.
-           glossary_guid : str, optional
-               The GUID of the glossary to search in. If not provided, the search will be performed in all glossaries.
-           status_filter : list, optional
-               A list of status values to filter the search results. Default is an empty list, which means no filtering.
-           server_name : str, optional
-               The name of the server where the glossaries reside. If not provided, it will use the default server name.
-           effective_time : datetime, optional
-               If specified, the term information will be retrieved if it is active at the `effective_time`.
-                Time format is "YYYY-MM-DDTHH:MM:SS" (ISO 8601)
-           for_lineage : bool, optional
-               Flag to indicate whether the search should include lineage information. Default is False.
-           for_duplicate_processing : bool, optional
-               Flag to indicate whether the search should include duplicate processing information. Default is False.
-           start_from : int, optional
-               The index of the first term to retrieve. Default is 0.
-           page_size : int, optional
-               The number of terms to retrieve per page. If not provided, it will use the default page size.
-
-           Returns
-           -------
-           list
-               A list of terms matching the search criteria. If no terms are found,
-               it returns the string "No terms found".
-
-           Raises
-           ------
-            InvalidParameterException
-                If the client passes incorrect parameters on the request - such as bad URLs or invalid values.
-            PropertyServerException
-                Raised by the server when an issue arises in processing a valid request.
-            NotAuthorizedException
-                The principle specified by the user_id does not have authorization for the requested action.
-           """
+    def get_terms_by_name(
+        self,
+        term: str,
+        glossary_guid: str = None,
+        status_filter: list = [],
+        server_name: str = None,
+        effective_time: str = None,
+        for_lineage: bool = False,
+        for_duplicate_processing: bool = False,
+        start_from: int = 0,
+        page_size: int = None,
+    ) -> list:
+        """Retrieve glossary terms by display name or qualified name.
+
+        Parameters
+        ----------
+        term : str
+            The term to search for in the glossaries.
+        glossary_guid : str, optional
+            The GUID of the glossary to search in. If not provided, the search will be performed in all glossaries.
+        status_filter : list, optional
+            A list of status values to filter the search results. Default is an empty list, which means no filtering.
+        server_name : str, optional
+            The name of the server where the glossaries reside. If not provided, it will use the default server name.
+        effective_time : datetime, optional
+            If specified, the term information will be retrieved if it is active at the `effective_time`.
+             Time format is "YYYY-MM-DDTHH:MM:SS" (ISO 8601)
+        for_lineage : bool, optional
+            Flag to indicate whether the search should include lineage information. Default is False.
+        for_duplicate_processing : bool, optional
+            Flag to indicate whether the search should include duplicate processing information. Default is False.
+        start_from : int, optional
+            The index of the first term to retrieve. Default is 0.
+        page_size : int, optional
+            The number of terms to retrieve per page. If not provided, it will use the default page size.
+
+        Returns
+        -------
+        list
+            A list of terms matching the search criteria. If no terms are found,
+            it returns the string "No terms found".
+
+        Raises
+        ------
+         InvalidParameterException
+             If the client passes incorrect parameters on the request - such as bad URLs or invalid values.
+         PropertyServerException
+             Raised by the server when an issue arises in processing a valid request.
+         NotAuthorizedException
+             The principle specified by the user_id does not have authorization for the requested action.
+        """
         loop = asyncio.get_event_loop()
         response = loop.run_until_complete(
-            self._async_get_terms_by_name(term, glossary_guid, status_filter, server_name, effective_time, for_lineage,
-                                          for_duplicate_processing, start_from, page_size))
+            self._async_get_terms_by_name(
+                term,
+                glossary_guid,
+                status_filter,
+                server_name,
+                effective_time,
+                for_lineage,
+                for_duplicate_processing,
+                start_from,
+                page_size,
+            )
+        )
         return response
 
-    async def _async_get_terms_by_guid(self, term_guid: str, server_name: str = None) -> dict | str:
-        """ Retrieve a term using its unique id. Async version.
+    async def _async_get_terms_by_guid(
+        self, term_guid: str, server_name: str = None
+    ) -> dict | str:
+        """Retrieve a term using its unique id. Async version.
         Parameters
         ----------
         term_guid : str
@@ -1652,14 +1964,16 @@ class GlossaryBrowser(Client):
 
         validate_guid(term_guid)
 
-        url = (f"{self.platform_url}/servers/{server_name}/api/open-metadata/glossary-browser/glossaries/terms/"
-               f"{term_guid}/retrieve")
+        url = (
+            f"{self.platform_url}/servers/{server_name}/api/open-metadata/glossary-browser/glossaries/terms/"
+            f"{term_guid}/retrieve"
+        )
 
         response = await self._async_make_request("POST", url)
         return response.json().get("element", "No term found")
 
     def get_terms_by_guid(self, term_guid: str, server_name: str = None) -> dict | str:
-        """ Retrieve a term using its unique id. Async version.
+        """Retrieve a term using its unique id. Async version.
         Parameters
         ----------
         term_guid : str
@@ -1684,13 +1998,20 @@ class GlossaryBrowser(Client):
         """
 
         loop = asyncio.get_event_loop()
-        response = loop.run_until_complete(self._async_get_terms_by_guid(term_guid, server_name))
+        response = loop.run_until_complete(
+            self._async_get_terms_by_guid(term_guid, server_name)
+        )
 
         return response
 
-    async def _async_get_terms_versions(self, term_guid: str, server_name: str = None, start_from: int = 0,
-                                        page_size=None) -> dict | str:
-        """ Retrieve the versions of a glossary term. Async version.
+    async def _async_get_terms_versions(
+        self,
+        term_guid: str,
+        server_name: str = None,
+        start_from: int = 0,
+        page_size=None,
+    ) -> dict | str:
+        """Retrieve the versions of a glossary term. Async version.
         Parameters
         ----------
         term_guid : str
@@ -1724,15 +2045,22 @@ class GlossaryBrowser(Client):
 
         validate_guid(term_guid)
 
-        url = (f"{self.platform_url}/servers/{server_name}/api/open-metadata/glossary-browser/glossaries/terms/"
-               f"{term_guid}/history?startFrom={start_from}&pageSize={page_size}")
+        url = (
+            f"{self.platform_url}/servers/{server_name}/api/open-metadata/glossary-browser/glossaries/terms/"
+            f"{term_guid}/history?startFrom={start_from}&pageSize={page_size}"
+        )
 
         response = await self._async_make_request("POST", url)
         return response.json().get("element", "No term found")
 
-    def get_terms_versions(self, term_guid: str, server_name: str = None, start_from: int = 0,
-                           page_size=None) -> dict | str:
-        """ Retrieve the versions of a glossary term.
+    def get_terms_versions(
+        self,
+        term_guid: str,
+        server_name: str = None,
+        start_from: int = 0,
+        page_size=None,
+    ) -> dict | str:
+        """Retrieve the versions of a glossary term.
         Parameters
         ----------
         term_guid : str
@@ -1761,13 +2089,21 @@ class GlossaryBrowser(Client):
 
         loop = asyncio.get_event_loop()
         response = loop.run_until_complete(
-            self._async_get_terms_versions(term_guid, server_name, start_from, page_size))
+            self._async_get_terms_versions(
+                term_guid, server_name, start_from, page_size
+            )
+        )
 
         return response
 
-    async def _async_get_term_revision_logs(self, term_guid: str, server_name: str = None, start_from: int = 0,
-                                            page_size=None) -> dict | str:
-        """ Retrieve the revision log history for a term. Async version.
+    async def _async_get_term_revision_logs(
+        self,
+        term_guid: str,
+        server_name: str = None,
+        start_from: int = 0,
+        page_size=None,
+    ) -> dict | str:
+        """Retrieve the revision log history for a term. Async version.
         Parameters
         ----------
         term_guid : str
@@ -1801,15 +2137,22 @@ class GlossaryBrowser(Client):
 
         validate_guid(term_guid)
 
-        url = (f"{self.platform_url}/servers/{server_name}/api/open-metadata/glossary-browser/elements/"
-               f"{term_guid}/notes/retrieve?startFrom={start_from}&pageSize={page_size}")
+        url = (
+            f"{self.platform_url}/servers/{server_name}/api/open-metadata/glossary-browser/elements/"
+            f"{term_guid}/notes/retrieve?startFrom={start_from}&pageSize={page_size}"
+        )
 
         response = await self._async_make_request("POST", url)
         return response.json().get("elementList", "No log found")
 
-    def get_term_revision_logs(self, term_guid: str, server_name: str = None, start_from: int = 0,
-                               page_size=None) -> dict | str:
-        """ Retrieve the revision log history for a term.
+    def get_term_revision_logs(
+        self,
+        term_guid: str,
+        server_name: str = None,
+        start_from: int = 0,
+        page_size=None,
+    ) -> dict | str:
+        """Retrieve the revision log history for a term.
         Parameters
         ----------
         term_guid : str
@@ -1838,13 +2181,21 @@ class GlossaryBrowser(Client):
 
         loop = asyncio.get_event_loop()
         response = loop.run_until_complete(
-            self._async_get_term_revision_logs(term_guid, server_name, start_from, page_size))
+            self._async_get_term_revision_logs(
+                term_guid, server_name, start_from, page_size
+            )
+        )
 
         return response
 
-    async def _async_get_term_revision_history(self, term_revision_log_guid: str, server_name: str = None,
-                                               start_from: int = 0, page_size=None) -> dict | str:
-        """ Retrieve the revision history for a glossary term. Async version.
+    async def _async_get_term_revision_history(
+        self,
+        term_revision_log_guid: str,
+        server_name: str = None,
+        start_from: int = 0,
+        page_size=None,
+    ) -> dict | str:
+        """Retrieve the revision history for a glossary term. Async version.
 
         Parameters
         ----------
@@ -1884,15 +2235,22 @@ class GlossaryBrowser(Client):
 
         validate_guid(term_revision_log_guid)
 
-        url = (f"{self.platform_url}/servers/{server_name}/api/open-metadata/glossary-browser/note-logs/"
-               f"{term_revision_log_guid}/notes/retrieve?startFrom={start_from}&pageSize={page_size}")
+        url = (
+            f"{self.platform_url}/servers/{server_name}/api/open-metadata/glossary-browser/note-logs/"
+            f"{term_revision_log_guid}/notes/retrieve?startFrom={start_from}&pageSize={page_size}"
+        )
 
         response = await self._async_make_request("POST", url)
         return response.json().get("elementList", "No logs found")
 
-    def get_term_revision_history(self, term_revision_log_guid: str, server_name: str = None, start_from: int = 0,
-                                  page_size=None) -> dict | str:
-        """ Retrieve the revision history for a glossary term.
+    def get_term_revision_history(
+        self,
+        term_revision_log_guid: str,
+        server_name: str = None,
+        start_from: int = 0,
+        page_size=None,
+    ) -> dict | str:
+        """Retrieve the revision history for a glossary term.
 
         Parameters
         ----------
@@ -1927,17 +2285,29 @@ class GlossaryBrowser(Client):
 
         loop = asyncio.get_event_loop()
         response = loop.run_until_complete(
-            self._async_get_term_revision_history(term_revision_log_guid, server_name, start_from, page_size))
+            self._async_get_term_revision_history(
+                term_revision_log_guid, server_name, start_from, page_size
+            )
+        )
 
         return response
 
-    async def _async_find_glossary_terms(self, search_string: str, glossary_guid: str = None, status_filter: list = [],
-                                         effective_time: str = None, starts_with: bool = False, ends_with: bool = False,
-                                         ignore_case: bool = False, for_lineage: bool = False,
-                                         for_duplicate_processing: bool = False, server_name: str = None,
-                                         start_from: int = 0, page_size: int = None) -> list | str:
-
-        """ Retrieve the list of glossary term metadata elements that contain the search string.
+    async def _async_find_glossary_terms(
+        self,
+        search_string: str,
+        glossary_guid: str = None,
+        status_filter: list = [],
+        effective_time: str = None,
+        starts_with: bool = False,
+        ends_with: bool = False,
+        ignore_case: bool = False,
+        for_lineage: bool = False,
+        for_duplicate_processing: bool = False,
+        server_name: str = None,
+        start_from: int = 0,
+        page_size: int = None,
+    ) -> list | str:
+        """Retrieve the list of glossary term metadata elements that contain the search string.
 
         Parameters
         ----------
@@ -1988,7 +2358,7 @@ class GlossaryBrowser(Client):
         -----
         The search string is located in the request body and is interpreted as a plain string.
         The request parameters, startsWith, endsWith and ignoreCase can be used to allow a fuzzy search.
-        The request body also supports the specification of a glossaryGUID to restrict the search to within a single 
+        The request body also supports the specification of a glossaryGUID to restrict the search to within a single
         glossary.
         """
         if server_name is None:
@@ -2002,100 +2372,137 @@ class GlossaryBrowser(Client):
         ignore_case_s = str(ignore_case).lower()
         for_lineage_s = str(for_lineage).lower()
         for_duplicate_processing_s = str(for_duplicate_processing).lower()
-        if search_string == '*':
+        if search_string == "*":
             search_string = None
 
         # validate_search_string(search_string)
 
-        body = {"class": "GlossarySearchStringRequestBody", "glossaryGUID": glossary_guid,
-                "searchString": search_string, "effectiveTime": effective_time, "limitResultsByStatus": status_filter}
+        body = {
+            "class": "GlossarySearchStringRequestBody",
+            "glossaryGUID": glossary_guid,
+            "searchString": search_string,
+            "effectiveTime": effective_time,
+            "limitResultsByStatus": status_filter,
+        }
         # body = body_slimmer(body)
 
-        url = (f"{self.platform_url}/servers/{server_name}/api/open-metadata/glossary-browser/glossaries/"
-               f"terms/by-search-string?startFrom={start_from}&pageSize={page_size}&startsWith={starts_with_s}&"
-               f"endsWith={ends_with_s}&ignoreCase={ignore_case_s}&forLineage={for_lineage_s}&"
-               f"forDuplicateProcessing={for_duplicate_processing_s}")
+        url = (
+            f"{self.platform_url}/servers/{server_name}/api/open-metadata/glossary-browser/glossaries/"
+            f"terms/by-search-string?startFrom={start_from}&pageSize={page_size}&startsWith={starts_with_s}&"
+            f"endsWith={ends_with_s}&ignoreCase={ignore_case_s}&forLineage={for_lineage_s}&"
+            f"forDuplicateProcessing={for_duplicate_processing_s}"
+        )
 
         # print(f"\n\nURL is: \n {url}\n\nBody is: \n{body}")
 
         response = await self._async_make_request("POST", url, body)
-        return response.json().get("elementList", "No terms found")  # return response.text
-
-    def find_glossary_terms(self, search_string: str, glossary_guid: str = None, status_filter: list = [],
-                            effective_time: str = None, starts_with: bool = False, ends_with: bool = False,
-                            ignore_case: bool = False, for_lineage: bool = False,
-                            for_duplicate_processing: bool = False, server_name: str = None, start_from: int = 0,
-                            page_size: int = None) -> list | str:
-        """ Retrieve the list of glossary term metadata elements that contain the search string.
-
-               Parameters
-               ----------
-               search_string: str
-                   Search string to use to find matching glossaries. If the search string is '*' then all glossaries 
-                   returned.
-               glossary_guid str
-                   Identifier of the glossary to search within. If None, then all glossaries are searched.
-               status_filter: list, default = [], optional
-                   Filters the results by the included Term statuses (such as 'ACTIVE', 'DRAFT'). If not specified,
-                   the results will not be filtered.
-               effective_time: str, [default=None], optional
-                   If specified, the term information will be retrieved if it is active at the `effective_time`.
-                   Time format is "YYYY-MM-DDTHH:MM:SS" (ISO 8601)
-               server_name : str, optional
-                   The name of the server to  configure.
-                   If not provided, the server name associated with the instance is used.
-               starts_with : bool, [default=False], optional
-                   Starts with the supplied string.
-               ends_with : bool, [default=False], optional
-                   Ends with the supplied string
-               ignore_case : bool, [default=False], optional
-                   Ignore case when searching
-               for_lineage : bool, [default=False], optional
-
-               for_duplicate_processing : bool, [default=False], optional
-
-               start_from: str, [default=0], optional
-                   Page of results to start from
-               page_size : int, optional
-                   Number of elements to return per page - if None, then default for class will be used.
-
-               Returns
-               -------
-               List | str
-
-               A list of term definitions
-
-               Raises
-               ------
-               InvalidParameterException
-                 If the client passes incorrect parameters on the request - such as bad URLs or invalid values
-               PropertyServerException
-                 Raised by the server when an issue arises in processing a valid request
-               NotAuthorizedException
-                 The principle specified by the user_id does not have authorization for the requested action
-
-               Notes
-               -----
-               The search string is located in the request body and is interpreted as a plain string.
-               The request parameters, startsWith, endsWith and ignoreCase can be used to allow a fuzzy search.
-               The request body also supports the specification of a glossaryGUID to restrict the search to within a 
-               single glossary.
-               """
+        return response.json().get(
+            "elementList", "No terms found"
+        )  # return response.text
+
+    def find_glossary_terms(
+        self,
+        search_string: str,
+        glossary_guid: str = None,
+        status_filter: list = [],
+        effective_time: str = None,
+        starts_with: bool = False,
+        ends_with: bool = False,
+        ignore_case: bool = False,
+        for_lineage: bool = False,
+        for_duplicate_processing: bool = False,
+        server_name: str = None,
+        start_from: int = 0,
+        page_size: int = None,
+    ) -> list | str:
+        """Retrieve the list of glossary term metadata elements that contain the search string.
+
+        Parameters
+        ----------
+        search_string: str
+            Search string to use to find matching glossaries. If the search string is '*' then all glossaries
+            returned.
+        glossary_guid str
+            Identifier of the glossary to search within. If None, then all glossaries are searched.
+        status_filter: list, default = [], optional
+            Filters the results by the included Term statuses (such as 'ACTIVE', 'DRAFT'). If not specified,
+            the results will not be filtered.
+        effective_time: str, [default=None], optional
+            If specified, the term information will be retrieved if it is active at the `effective_time`.
+            Time format is "YYYY-MM-DDTHH:MM:SS" (ISO 8601)
+        server_name : str, optional
+            The name of the server to  configure.
+            If not provided, the server name associated with the instance is used.
+        starts_with : bool, [default=False], optional
+            Starts with the supplied string.
+        ends_with : bool, [default=False], optional
+            Ends with the supplied string
+        ignore_case : bool, [default=False], optional
+            Ignore case when searching
+        for_lineage : bool, [default=False], optional
+
+        for_duplicate_processing : bool, [default=False], optional
+
+        start_from: str, [default=0], optional
+            Page of results to start from
+        page_size : int, optional
+            Number of elements to return per page - if None, then default for class will be used.
+
+        Returns
+        -------
+        List | str
+
+        A list of term definitions
+
+        Raises
+        ------
+        InvalidParameterException
+          If the client passes incorrect parameters on the request - such as bad URLs or invalid values
+        PropertyServerException
+          Raised by the server when an issue arises in processing a valid request
+        NotAuthorizedException
+          The principle specified by the user_id does not have authorization for the requested action
+
+        Notes
+        -----
+        The search string is located in the request body and is interpreted as a plain string.
+        The request parameters, startsWith, endsWith and ignoreCase can be used to allow a fuzzy search.
+        The request body also supports the specification of a glossaryGUID to restrict the search to within a
+        single glossary.
+        """
 
         loop = asyncio.get_event_loop()
         response = loop.run_until_complete(
-            self._async_find_glossary_terms(search_string, glossary_guid, status_filter, effective_time, starts_with,
-                                            ends_with, ignore_case, for_lineage, for_duplicate_processing, server_name,
-                                            start_from, page_size))
+            self._async_find_glossary_terms(
+                search_string,
+                glossary_guid,
+                status_filter,
+                effective_time,
+                starts_with,
+                ends_with,
+                ignore_case,
+                for_lineage,
+                for_duplicate_processing,
+                server_name,
+                start_from,
+                page_size,
+            )
+        )
 
         return response
 
     #
     #   Feedback
     #
-    async def _async_get_comment(self, commemt_guid: str, effective_time: str, server_name: str = None,
-                                 for_lineage: bool = False, for_duplicate_processing: bool = False) -> dict | list:
-        """ Retrieve the comment specified by the comment GUID """
+    async def _async_get_comment(
+        self,
+        commemt_guid: str,
+        effective_time: str,
+        server_name: str = None,
+        for_lineage: bool = False,
+        for_duplicate_processing: bool = False,
+    ) -> dict | list:
+        """Retrieve the comment specified by the comment GUID"""
         if server_name is None:
             server_name = self.server_name
 
@@ -2109,19 +2516,28 @@ class GlossaryBrowser(Client):
 
         body = {"effective_time": effective_time}
 
-        url = (f"{self.platform_url}/servers/{server_name}/api/open-metadata/glossary-browser/comments/"
-               f"{commemt_guid}?forLineage={for_lineage_s}&"
-               f"forDuplicateProcessing={for_duplicate_processing_s}")
+        url = (
+            f"{self.platform_url}/servers/{server_name}/api/open-metadata/glossary-browser/comments/"
+            f"{commemt_guid}?forLineage={for_lineage_s}&"
+            f"forDuplicateProcessing={for_duplicate_processing_s}"
+        )
 
         # print(f"\n\nURL is: \n {url}\n\nBody is: \n{body}")
 
         response = await self._async_make_request("POST", url, body)
         return response.json()
 
-    async def _async_add_comment_reply(self, comment_guid: str, is_public: bool, comment_type: str, comment_text: str,
-                                       server_name: str = None, for_lineage: bool = False,
-                                       for_duplicate_processing: bool = False) -> str:
-        """ Reply to a comment """
+    async def _async_add_comment_reply(
+        self,
+        comment_guid: str,
+        is_public: bool,
+        comment_type: str,
+        comment_text: str,
+        server_name: str = None,
+        for_lineage: bool = False,
+        for_duplicate_processing: bool = False,
+    ) -> str:
+        """Reply to a comment"""
 
         if server_name is None:
             server_name = self.server_name
@@ -2133,22 +2549,36 @@ class GlossaryBrowser(Client):
         for_lineage_s = str(for_lineage).lower()
         for_duplicate_processing_s = str(for_duplicate_processing).lower()
 
-        body = {"class": "CommentRequestBody", "commentType": comment_type, "commentText": comment_text,
-                "isPublic": is_public}
+        body = {
+            "class": "CommentRequestBody",
+            "commentType": comment_type,
+            "commentText": comment_text,
+            "isPublic": is_public,
+        }
 
-        url = (f"{self.platform_url}/servers/{server_name}/api/open-metadata/glossary-browser/comments/"
-               f"{comment_guid}/replies?isPublic={is_public_s}&forLineage={for_lineage_s}&"
-               f"forDuplicateProcessing={for_duplicate_processing_s}")
+        url = (
+            f"{self.platform_url}/servers/{server_name}/api/open-metadata/glossary-browser/comments/"
+            f"{comment_guid}/replies?isPublic={is_public_s}&forLineage={for_lineage_s}&"
+            f"forDuplicateProcessing={for_duplicate_processing_s}"
+        )
 
         # print(f"\n\nURL is: \n {url}\n\nBody is: \n{body}")
 
         response = await self._async_make_request("POST", url, body)
         return response
 
-    async def _async_update_comment(self, comment_guid: str, is_public: bool, comment_type: str, comment_text: str,
-                                    server_name: str = None, is_merge_update: bool = False, for_lineage: bool = False,
-                                    for_duplicate_processing: bool = False) -> str:
-        """ Update the specified comment"""
+    async def _async_update_comment(
+        self,
+        comment_guid: str,
+        is_public: bool,
+        comment_type: str,
+        comment_text: str,
+        server_name: str = None,
+        is_merge_update: bool = False,
+        for_lineage: bool = False,
+        for_duplicate_processing: bool = False,
+    ) -> str:
+        """Update the specified comment"""
         if server_name is None:
             server_name = self.server_name
 
@@ -2159,23 +2589,39 @@ class GlossaryBrowser(Client):
         for_lineage_s = str(for_lineage).lower()
         for_duplicate_processing_s = str(for_duplicate_processing).lower()
 
-        body = {"class": "CommentRequestBody", "commentType": comment_type, "commentText": comment_text,
-                "isPublic": is_public}
+        body = {
+            "class": "CommentRequestBody",
+            "commentType": comment_type,
+            "commentText": comment_text,
+            "isPublic": is_public,
+        }
 
-        url = (f"{self.platform_url}/servers/{server_name}/api/open-metadata/glossary-browser/comments/"
-               f"{comment_guid}/replies?isPublic={is_public_s}&forLineage={for_lineage_s}&"
-               f"forDuplicateProcessing={for_duplicate_processing_s}")
+        url = (
+            f"{self.platform_url}/servers/{server_name}/api/open-metadata/glossary-browser/comments/"
+            f"{comment_guid}/replies?isPublic={is_public_s}&forLineage={for_lineage_s}&"
+            f"forDuplicateProcessing={for_duplicate_processing_s}"
+        )
 
         # print(f"\n\nURL is: \n {url}\n\nBody is: \n{body}")
 
         response = await self._async_make_request("POST", url, body)
         return response
 
-    async def _async_find_comment(self, search_string: str, glossary_guid: str = None, status_filter: list = [],
-                                  effective_time: str = None, starts_with: bool = False, ends_with: bool = False,
-                                  ignore_case: bool = False, for_lineage: bool = False,
-                                  for_duplicate_processing: bool = False, server_name: str = None, start_from: int = 0,
-                                  page_size: int = None):
+    async def _async_find_comment(
+        self,
+        search_string: str,
+        glossary_guid: str = None,
+        status_filter: list = [],
+        effective_time: str = None,
+        starts_with: bool = False,
+        ends_with: bool = False,
+        ignore_case: bool = False,
+        for_lineage: bool = False,
+        for_duplicate_processing: bool = False,
+        server_name: str = None,
+        start_from: int = 0,
+        page_size: int = None,
+    ):
         """Find comments by search string"""
         if server_name is None:
             server_name = self.server_name
@@ -2188,19 +2634,26 @@ class GlossaryBrowser(Client):
         ignore_case_s = str(ignore_case).lower()
         for_lineage_s = str(for_lineage).lower()
         for_duplicate_processing_s = str(for_duplicate_processing).lower()
-        if search_string == '*':
+        if search_string == "*":
             search_string = None
 
         # validate_search_string(search_string)
 
-        body = {"class": "GlossarySearchStringRequestBody", "glossaryGUID": glossary_guid,
-                "searchString": search_string, "effectiveTime": effective_time, "limitResultsByStatus": status_filter}
+        body = {
+            "class": "GlossarySearchStringRequestBody",
+            "glossaryGUID": glossary_guid,
+            "searchString": search_string,
+            "effectiveTime": effective_time,
+            "limitResultsByStatus": status_filter,
+        }
         # body = body_slimmer(body)
 
-        url = (f"{self.platform_url}/servers/{server_name}/api/open-metadata/glossary-browser/glossaries/"
-               f"terms/by-search-string?startFrom={start_from}&pageSize={page_size}&startsWith={starts_with_s}&"
-               f"endsWith={ends_with_s}&ignoreCase={ignore_case_s}&forLineage={for_lineage_s}&"
-               f"forDuplicateProcessing={for_duplicate_processing_s}")
+        url = (
+            f"{self.platform_url}/servers/{server_name}/api/open-metadata/glossary-browser/glossaries/"
+            f"terms/by-search-string?startFrom={start_from}&pageSize={page_size}&startsWith={starts_with_s}&"
+            f"endsWith={ends_with_s}&ignoreCase={ignore_case_s}&forLineage={for_lineage_s}&"
+            f"forDuplicateProcessing={for_duplicate_processing_s}"
+        )
 
         # print(f"\n\nURL is: \n {url}\n\nBody is: \n{body}")