pyegeria 5.3.8.4__py3-none-any.whl → 5.3.8.6__py3-none-any.whl

pyegeria/glossary_browser_omvs.py

@@ -2327,1137 +2327,1137 @@ class GlossaryBrowser(Client):
     #  Terms
     #
 
-async def _async_get_terms_for_category(self, glossary_category_guid: str, effective_time: str = None,
-        start_from: int = 0, page_size: int = None, ) -> list | str:
-    """Retrieve ALL the glossary terms in a category.
-        The request body also supports the specification of an effective time for the query.
-
-        Async Version.
-
-    Parameters
-    ----------
-        glossary_category_guid : str
-            Unique identifier for the glossary category to retrieve terms from.
-        effective_time : str, optional
-            If specified, the terms are returned if they are active at the `effective_time
+    async def _async_get_terms_for_category(self, glossary_category_guid: str, effective_time: str = None,
+            start_from: int = 0, page_size: int = None, ) -> list | str:
+        """Retrieve ALL the glossary terms in a category.
+            The request body also supports the specification of an effective time for the query.
+
+            Async Version.
+
+        Parameters
+        ----------
+            glossary_category_guid : str
+                Unique identifier for the glossary category to retrieve terms from.
+            effective_time : str, optional
+                If specified, the terms are returned if they are active at the `effective_time
+                Time format is "YYYY-MM-DDTHH:MM:SS" (ISO 8601)
+            start_from: int, optional defaults to 0
+                The page number to start retrieving elements from
+            page_size : int, optional defaults to None
+                The number of elements to retrieve
+        Returns
+        -------
+        [dict]
+            The glossary definition associated with the glossary_guid
+
+        Raises
+        ------
+         InvalidParameterException
+             If the client passes incorrect parameters on the request - such as bad URLs or invalid values.
+         PropertyServerException
+             Raised by the server when an issue arises in processing a valid request.
+         NotAuthorizedException
+             The principle specified by the user_id does not have authorization for the requested action.
+
+        """
+
+        validate_guid(glossary_category_guid)
+
+        if page_size is None:
+            page_size = self.page_size
+
+        url = (
+            f"{self.platform_url}/servers/{self.view_server}/api/open-metadata/glossary-browser/glossaries/categories/"
+            f"{glossary_category_guid}/terms/retrieve?startFrom={start_from}&pageSize={page_size}")
+
+        if effective_time is not None:
+            body = {"effectiveTime": effective_time}
+            response = await self._async_make_request("POST", url, body)
+        else:
+            response = await self._async_make_request("POST", url)
+
+        return response.json().get("elementList", "No terms found")
+
+    def get_terms_for_category(self, glossary_category_guid: str, effective_time: str = None, start_from: int = 0,
+            page_size: int = None, ) -> list | str:
+        """Retrieve ALL the glossary terms in a category.
+            The request body also supports the specification of an effective time for the query.
+
+            Async Version.
+
+        Parameters
+        ----------
+            glossary_category_guid : str
+                Unique identifier for the glossary category to retrieve terms from.
+
+            effective_time : str, optional
+                If specified, the terms are returned if they are active at the `effective_time.
+                Time format is "YYYY-MM-DDTHH:MM:SS" (ISO 8601)`.
+            start_from: int, optional defaults to 0
+                The page number to start retrieving elements from
+            page_size : int, optional defaults to None
+                The number of elements to retrieve
+        Returns
+        -------
+        dict
+            The glossary definition associated with the glossary_guid
+
+        Raises
+        ------
+         InvalidParameterException
+             If the client passes incorrect parameters on the request - such as bad URLs or invalid values.
+         PropertyServerException
+             Raised by the server when an issue arises in processing a valid request.
+         NotAuthorizedException
+             The principle specified by the user_id does not have authorization for the requested action.
+        Notes
+        -----
+        """
+        loop = asyncio.get_event_loop()
+        response = loop.run_until_complete(
+            self._async_get_terms_for_category(glossary_category_guid, effective_time, start_from, page_size, ))
+
+        return response
+
+    async def _async_get_terms_for_glossary(self, glossary_guid: str, 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
+        ----------
+            glossary_guid : str
+                Unique identifier for the glossary
+
+            effective_time : str, optional
+                If specified, terms are potentially included if they are active at the`effective_time.
+                Time format is "YYYY-MM-DDTHH:MM:SS" (ISO 8601)`
+            start_from: int, optional defaults to 0
+                The page number to start retrieving elements from
+            page_size : int, optional defaults to None
+                The number of elements to retrieve
+        Returns
+        -------
+        dict
+            The glossary definition associated with the glossary_guid
+
+        Raises
+        ------
+         InvalidParameterException
+             If the client passes incorrect parameters on the request - such as bad URLs or invalid values.
+         PropertyServerException
+             Raised by the server when an issue arises in processing a valid request.
+         NotAuthorizedException
+             The principle specified by the user_id does not have authorization for the requested action.
+        Notes
+        -----
+        """
+
+        validate_guid(glossary_guid)
+
+        if page_size is None:
+            page_size = self.page_size
+
+        url = (f"{self.platform_url}/servers/{self.view_server}/api/open-metadata/glossary-browser/glossaries/"
+               f"{glossary_guid}/terms/retrieve?startFrom={start_from}&pageSize={page_size}")
+
+        if effective_time is not None:
+            body = {"effectiveTime": effective_time}
+            response = await self._async_make_request("POST", url, body)
+        else:
+            response = await self._async_make_request("POST", url)
+
+        return response.json().get("elementList", "No terms found")
+
+    def get_terms_for_glossary(self, glossary_guid: str, 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
+        ----------
+            glossary_guid : str
+                Unique identifier for the glossary
+
+            effective_time : str, optional
+                If specified, terms are potentially returned if they are active at the `effective_time`
+                Time format is "YYYY-MM-DDTHH:MM:SS" (ISO 8601)
+            start_from: int, optional defaults to 0
+                The page number to start retrieving elements from
+            page_size : int, optional defaults to None
+                The number of elements to retrieve
+        Returns
+        -------
+        dict
+            The glossary definition associated with the glossary_guid
+
+        Raises
+        ------
+         InvalidParameterException
+             If the client passes incorrect parameters on the request - such as bad URLs or invalid values.
+         PropertyServerException
+             Raised by the server when an issue arises in processing a valid request.
+         NotAuthorizedException
+             The principle specified by the user_id does not have authorization for the requested action.
+        Notes
+        -----
+        """
+        loop = asyncio.get_event_loop()
+        response = loop.run_until_complete(
+            self._async_get_terms_for_glossary(glossary_guid, effective_time, start_from, page_size))
+
+        return response
+
+    async def _async_get_term_relationships(self, term_guid: str, effective_time: str = None, start_from: int = 0,
+            page_size: int = None, ) -> list | str:
+        """This call retrieves details of the glossary terms linked to this glossary term.
+        Notice the original org 1 glossary term is linked via the "SourcedFrom" relationship..
+        Parameters
+        ----------
+            term_guid : str
+                Unique identifier for the glossary term
+
+            effective_time : str, optional
+                If specified, term relationships are included if they are active at the `effective_time`.
+                Time format is "YYYY-MM-DDTHH:MM:SS" (ISO 8601)
+            start_from: int, optional defaults to 0
+                The page number to start retrieving elements from
+            page_size : int, optional defaults to None
+                The number of elements to retrieve
+        Returns
+        -------
+        dict
+            The glossary definition associated with the glossary_guid
+
+        Raises
+        ------
+         InvalidParameterException
+             If the client passes incorrect parameters on the request - such as bad URLs or invalid values.
+         PropertyServerException
+             Raised by the server when an issue arises in processing a valid request.
+         NotAuthorizedException
+             The principle specified by the user_id does not have authorization for the requested action.
+        Notes
+        -----
+        """
+
+        validate_guid(term_guid)
+
+        if page_size is None:
+            page_size = self.page_size
+
+        url = (f"{self.platform_url}/servers/{self.view_server}/api/open-metadata/glossary-browser/glossaries/terms/"
+               f"{term_guid}/related-terms?startFrom={start_from}&pageSize={page_size}")
+
+        if effective_time is not None:
+            body = {"effectiveTime": effective_time}
+            response = await self._async_make_request("POST", url, body)
+        else:
+            response = await self._async_make_request("POST", url)
+
+        return response.json().get("elementList", "No terms found")
+
+    def get_term_relationships(self, term_guid: str, effective_time: str = None, start_from: int = 0,
+            page_size: int = None, ) -> list | str:
+        """This call retrieves details of the glossary terms linked to this glossary term.
+        Notice the original org 1 glossary term is linked via the "SourcedFrom" relationship..
+        Parameters
+        ----------
+            term_guid : str
+                Unique identifier for the glossary term
+
+            effective_time : str, optional
+                If specified, term relationships are included if they are active at the `effective_time`.
+                Time format is "YYYY-MM-DDTHH:MM:SS" (ISO 8601)
+            start_from: int, optional defaults to 0
+                The page number to start retrieving elements from
+            page_size : int, optional defaults to None
+                The number of elements to retrieve
+        Returns
+        -------
+        dict
+            The glossary definition associated with the glossary_guid
+
+        Raises
+        ------
+         InvalidParameterException
+             If the client passes incorrect parameters on the request - such as bad URLs or invalid values.
+         PropertyServerException
+             Raised by the server when an issue arises in processing a valid request.
+         NotAuthorizedException
+             The principle specified by the user_id does not have authorization for the requested action.
+        Notes
+        -----
+        """
+        loop = asyncio.get_event_loop()
+        response = loop.run_until_complete(
+            self._async_get_term_relationships(term_guid, effective_time, start_from, page_size))
+
+        return response
+
+    async def _async_get_glossary_for_term(self, term_guid: str, effective_time: str = None) -> dict | str:
+        """Retrieve the glossary metadata element for the requested term.  The optional request body allows you to
+            specify that the glossary element should only be returned if it was effective at a particular time.
+
+            Async Version.
+
+        Parameters
+        ----------
+        term_guid : str
+            The unique identifier for the term.
+
+        effective_time : datetime, optional
+            If specified, the term information will be retrieved if it is active at the `effective_time`.
             Time format is "YYYY-MM-DDTHH:MM:SS" (ISO 8601)
-        start_from: int, optional defaults to 0
-            The page number to start retrieving elements from
-        page_size : int, optional defaults to None
-            The number of elements to retrieve
-    Returns
-    -------
-    [dict]
-        The glossary definition associated with the glossary_guid
-
-    Raises
-    ------
-     InvalidParameterException
-         If the client passes incorrect parameters on the request - such as bad URLs or invalid values.
-     PropertyServerException
-         Raised by the server when an issue arises in processing a valid request.
-     NotAuthorizedException
-         The principle specified by the user_id does not have authorization for the requested action.
 
-    """
+        Returns
+        -------
+        dict
+            The glossary information retrieved for the specified term.
+        Raises
+        ------
+         InvalidParameterException
+             If the client passes incorrect parameters on the request - such as bad URLs or invalid values.
+         PropertyServerException
+             Raised by the server when an issue arises in processing a valid request.
+         NotAuthorizedException
+             The principle specified by the user_id does not have authorization for the requested action.
+        Notes
+        -----
+        """
+
+        validate_guid(term_guid)
+
+        body = {
+            "class": "EffectiveTimeQueryRequestBody", "effectiveTime": effective_time,
+            }
+        url = (f"{self.platform_url}/servers/{self.view_server}/api/open-metadata/glossary-browser/glossaries/"
+               f"for-term/{term_guid}/retrieve")
+
+        response = await self._async_make_request("POST", url, body)
+        return response.json().get("element", "No glossary found")
+
+    def get_glossary_for_term(self, term_guid: str, effective_time: str = None) -> dict | str:
+        """Retrieve the glossary metadata element for the requested term.  The optional request body allows you to
+            specify that the glossary element should only be returned if it was effective at a particular time.
+
+            Async Version.
+
+        Parameters
+        ----------
+        term_guid : str
+            The unique identifier for the term.
+
+        effective_time : datetime, optional
+            TIf specified, the term information will be retrieved if it is active at the `effective_time`.
+            Time format is "YYYY-MM-DDTHH:MM:SS" (ISO 8601).
+
+        Returns
+        -------
+        dict
+            The glossary information retrieved for the specified term.
+        Raises
+        ------
+         InvalidParameterException
+             If the client passes incorrect parameters on the request - such as bad URLs or invalid values.
+         PropertyServerException
+             Raised by the server when an issue arises in processing a valid request.
+         NotAuthorizedException
+             The principle specified by the user_id does not have authorization for the requested action.
+        Notes
+        -----
+        """
+        loop = asyncio.get_event_loop()
+        response = loop.run_until_complete(self._async_get_glossary_for_term(term_guid, effective_time))
+        return response
+
+    async def _async_get_terms_by_name(self, term: str, glossary_guid: str = None, status_filter: list = [],
+            effective_time: str = None, for_lineage: bool = False, for_duplicate_processing: bool = False,
+            start_from: int = 0, page_size: int = None, ) -> list:
+        """Retrieve glossary terms by display name or qualified name. Async Version.
+
+        Parameters
+        ----------
+        term : str
+            The term to search for in the glossaries.
+        glossary_guid : str, optional
+            The GUID of the glossary to search in. If not provided, the search will be performed in all glossaries.
+        status_filter : list, optional
+            A list of status values to filter the search results. Default is an empty list, which means no filtering.
+
+        effective_time : datetime, optional
+            If specified, the term information will be retrieved if it is active at the `effective_time`.
+            Time format is "YYYY-MM-DDTHH:MM:SS" (ISO 8601)
+        for_lineage : bool, optional
+            Flag to indicate whether the search should include lineage information. Default is False.
+        for_duplicate_processing : bool, optional
+            Flag to indicate whether the search should include duplicate processing information. Default is False.
+        start_from : int, optional
+            The index of the first term to retrieve. Default is 0.
+        page_size : int, optional
+            The number of terms to retrieve per page. If not provided, it will use the default page size.
+
+        Returns
+        -------
+        list
+            A list of terms matching the search criteria. If no terms are found, it returns the string "No terms found".
+
+        Raises
+        ------
+         InvalidParameterException
+             If the client passes incorrect parameters on the request - such as bad URLs or invalid values.
+         PropertyServerException
+             Raised by the server when an issue arises in processing a valid request.
+         NotAuthorizedException
+             The principle specified by the user_id does not have authorization for the requested action.
+        """
+
+        if page_size is None:
+            page_size = self.page_size
+
+        validate_name(term)
+
+        for_lineage_s = str(for_lineage).lower()
+        for_duplicate_processing_s = str(for_duplicate_processing).lower()
+
+        body = {
+            "class": "GlossaryNameRequestBody", "glossaryGUID": glossary_guid, "name": term,
+            "effectiveTime": effective_time, "limitResultsByStatus": status_filter,
+            }
+        # body = body_slimmer(body)
+
+        url = (f"{self.platform_url}/servers/{self.view_server}/api/open-metadata/glossary-browser/glossaries/"
+               f"terms/by-name?startFrom={start_from}&pageSize={page_size}&"
+               f"&forLineage={for_lineage_s}&forDuplicateProcessing={for_duplicate_processing_s}")
+
+        # print(f"\n\nURL is: \n {url}\n\nBody is: \n{body}")
+
+        response = await self._async_make_request("POST", url, body)
+        return response.json().get("elementList", "No terms found")
+
+    def get_terms_by_name(self, term: str, glossary_guid: str = None, status_filter: list = [],
+            effective_time: str = None, for_lineage: bool = False, for_duplicate_processing: bool = False,
+            start_from: int = 0, page_size: int = None, ) -> list:
+        """Retrieve glossary terms by display name or qualified name.
+
+        Parameters
+        ----------
+        term : str
+            The term to search for in the glossaries.
+        glossary_guid : str, optional
+            The GUID of the glossary to search in. If not provided, the search will be performed in all glossaries.
+        status_filter : list, optional
+            A list of status values to filter the search results. Default is an empty list, which means no filtering.
+
+        effective_time : datetime, optional
+            If specified, the term information will be retrieved if it is active at the `effective_time`.
+             Time format is "YYYY-MM-DDTHH:MM:SS" (ISO 8601)
+        for_lineage : bool, optional
+            Flag to indicate whether the search should include lineage information. Default is False.
+        for_duplicate_processing : bool, optional
+            Flag to indicate whether the search should include duplicate processing information. Default is False.
+        start_from : int, optional
+            The index of the first term to retrieve. Default is 0.
+        page_size : int, optional
+            The number of terms to retrieve per page. If not provided, it will use the default page size.
+
+        Returns
+        -------
+        list
+            A list of terms matching the search criteria. If no terms are found,
+            it returns the string "No terms found".
+
+        Raises
+        ------
+         InvalidParameterException
+             If the client passes incorrect parameters on the request - such as bad URLs or invalid values.
+         PropertyServerException
+             Raised by the server when an issue arises in processing a valid request.
+         NotAuthorizedException
+             The principle specified by the user_id does not have authorization for the requested action.
+        """
+        loop = asyncio.get_event_loop()
+        response = loop.run_until_complete(
+            self._async_get_terms_by_name(term, glossary_guid, status_filter, effective_time, for_lineage,
+                for_duplicate_processing, start_from, page_size, ))
+        return response
+
+    async def _async_get_term_by_guid(self, term_guid: str, output_format: str = 'JSON') -> dict | str:
+        """Retrieve a term using its unique id. Async version.
+        Parameters
+        ----------
+        term_guid : str
+            The GUID of the glossary term to retrieve.
+        output_format: str, default = 'JSON'
+            Type of output to produce:
+                JSON - output standard json
+                MD - output standard markdown with no preamble
+                FORM - output markdown with a preamble for a form
+                REPORT - output markdown with a preamble for a report
+
+        Returns
+        -------
+        dict | str
+            A dict detailing the glossary term represented by the GUID. If no term is found, the string
+            "No term found" will be returned.
+
+        Raises
+        ------
+        InvalidParameterException
+            If the client passes incorrect parameters on the request - such as bad URLs or invalid values.
+        PropertyServerException
+            Raised by the server when an issue arises in processing a valid request.
+        NotAuthorizedException
+            The principle specified by the user_id does not have authorization for the requested action.
+        """
+        output_format = output_format.upper()
+        validate_guid(term_guid)
+
+        url = (f"{self.platform_url}/servers/{self.view_server}/api/open-metadata/glossary-browser/glossaries/terms/"
+               f"{term_guid}/retrieve")
+        response = await self._async_make_request("POST", url)
+        term_element = response.json().get("element", NO_TERMS_FOUND)
+        if term_element == NO_TERMS_FOUND:
+            return NO_TERMS_FOUND
+        if output_format != 'JSON':  # return a simplified markdown representation
+            return self.generate_terms_md(term_element, "GUID", output_format)
+        return response.json().get("element", NO_TERMS_FOUND)
+
+    def get_term_by_guid(self, term_guid: str, output_format: str = 'JSON') -> dict | str:
+        """Retrieve a term using its unique id. Async version.
+        Parameters
+        ----------
+        term_guid : str
+            The GUID of the glossary term to retrieve.
+        output_format: str, default = 'JSON'
+            Type of output to produce:
+                JSON - output standard json
+                MD - output standard markdown with no preamble
+                FORM - output markdown with a preamble for a form
+                REPORT - output markdown with a preamble for a report
+        Returns
+        -------
+        dict | str
+            A dict detailing the glossary term represented by the GUID. If no term is found, the string
+            "No term found" will be returned.
+        Raises
+        ------
+        InvalidParameterException
+            If the client passes incorrect parameters on the request - such as bad URLs or invalid values.
+        PropertyServerException
+            Raised by the server when an issue arises in processing a valid request.
+        NotAuthorizedException
+            The principle specified by the user_id does not have authorization for the requested action.
+        """
+
+        loop = asyncio.get_event_loop()
+        response = loop.run_until_complete(self._async_get_term_by_guid(term_guid, output_format))
+
+        return response
+
+    async def _async_get_term_versions(self, term_guid: str, effective_time: str = None, from_time: str = None,
+            to_time: str = None, oldest_first: bool = False, for_lineage: bool = False,
+            for_duplicate_processing: bool = False, start_from: int = 0, page_size=max_paging_size,
+
+            ) -> list | str:
+        """Retrieve the versions of a glossary term. Async version.
+        Parameters
+        ----------
+        term_guid : str
+            The GUID of the glossary term to retrieve.
+
+        start_from : int, optional
+            The index of the first term to retrieve. Default is 0.
+        page_size : int, optional
+            The number of terms to retrieve per page. If not provided, it will use the default page size.
+        Returns
+        -------
+        list | str
+            A [dict] detailing the glossary term represented by the GUID. If no term is found, the string
+            "No term found" will be returned.
+
+        Raises
+        ------
+        InvalidParameterException
+            If the client passes incorrect parameters on the request - such as bad URLs or invalid values.
+        PropertyServerException
+            Raised by the server when an issue arises in processing a valid request.
+        NotAuthorizedException
+            The principle specified by the user_id does not have authorization for the requested action.
+
+        Args:
+            term_guid:
+            effective_time:
+            from_time:
+            to_time:
+            oldest_first:
+            for_lineage:
+            for_duplicate_processing:
+            start_from:
+            page_size:
+        """
+
+        body = {
+            "effective_time": effective_time, "fromTime": from_time, "toTime": to_time, "forLineage": for_lineage,
+            "forDuplicateProcessing": for_duplicate_processing
+            }
+
+        oldest_first_s = str(oldest_first).lower()
+        validate_guid(term_guid)
+
+        url = (f"{self.platform_url}/servers/{self.view_server}/api/open-metadata/glossary-browser/glossaries/terms/"
+               f"{term_guid}/history?startFrom={start_from}&pageSize={page_size}&oldestFirst={oldest_first_s}&"
+               f"forDuplicateProcessing={for_duplicate_processing}&forLineage={for_lineage}")
+
+        response = await self._async_make_request("POST", url, body_slimmer(body))
+        return response.json().get("elementList", "No term found")
+
+    def get_term_versions(self, term_guid: str, effective_time: str = None, from_time: str = None, to_time: str = None,
+            oldest_first: bool = False, for_lineage: bool = False, for_duplicate_processing: bool = False,
+            start_from: int = 0, page_size=max_paging_size, ) -> dict | str:
+        """Retrieve the versions of a glossary term.
+        Parameters
+        ----------
+        term_guid : str
+            The GUID of the glossary term to retrieve.
+
+        start_from : int, optional
+            The index of the first term to retrieve. Default is 0.
+        page_size : int, optional
+            The number of terms to retrieve per page. If not provided, it will use the default page size.
+        Returns
+        -------
+        [dict] | str
+            A [dict] detailing the glossary term represented by the GUID. If no term is found, the string
+            "No term found" will be returned.
 
-    validate_guid(glossary_category_guid)
+        Raises
+        ------
+        InvalidParameterException
+            If the client passes incorrect parameters on the request - such as bad URLs or invalid values.
+        PropertyServerException
+            Raised by the server when an issue arises in processing a valid request.
+        NotAuthorizedException
+            The principle specified by the user_id does not have authorization for the requested action.
+        """
 
-    if page_size is None:
-        page_size = self.page_size
+        loop = asyncio.get_event_loop()
+        response = loop.run_until_complete(
+            self._async_get_term_versions(term_guid, effective_time, from_time, to_time, oldest_first, for_lineage,
+                                          for_duplicate_processing, start_from, page_size))
 
-    url = (
-        f"{self.platform_url}/servers/{self.view_server}/api/open-metadata/glossary-browser/glossaries/categories/"
-        f"{glossary_category_guid}/terms/retrieve?startFrom={start_from}&pageSize={page_size}")
+        return response
 
-    if effective_time is not None:
-        body = {"effectiveTime": effective_time}
-        response = await self._async_make_request("POST", url, body)
-    else:
-        response = await self._async_make_request("POST", url)
+    async def _async_get_term_revision_logs(self, term_guid: str, start_from: int = 0, page_size=None, ) -> dict | str:
+        """Retrieve the revision log history for a term. Async version.
+        Parameters
+        ----------
+        term_guid : str
+            The GUID of the glossary term to retrieve.
 
-    return response.json().get("elementList", "No terms found")
-
-def get_terms_for_category(self, glossary_category_guid: str, effective_time: str = None, start_from: int = 0,
-        page_size: int = None, ) -> list | str:
-    """Retrieve ALL the glossary terms in a category.
-        The request body also supports the specification of an effective time for the query.
-
-        Async Version.
-
-    Parameters
-    ----------
-        glossary_category_guid : str
-            Unique identifier for the glossary category to retrieve terms from.
-
-        effective_time : str, optional
-            If specified, the terms are returned if they are active at the `effective_time.
-            Time format is "YYYY-MM-DDTHH:MM:SS" (ISO 8601)`.
-        start_from: int, optional defaults to 0
-            The page number to start retrieving elements from
-        page_size : int, optional defaults to None
-            The number of elements to retrieve
-    Returns
-    -------
-    dict
-        The glossary definition associated with the glossary_guid
-
-    Raises
-    ------
-     InvalidParameterException
-         If the client passes incorrect parameters on the request - such as bad URLs or invalid values.
-     PropertyServerException
-         Raised by the server when an issue arises in processing a valid request.
-     NotAuthorizedException
-         The principle specified by the user_id does not have authorization for the requested action.
-    Notes
-    -----
-    """
-    loop = asyncio.get_event_loop()
-    response = loop.run_until_complete(
-        self._async_get_terms_for_category(glossary_category_guid, effective_time, start_from, page_size, ))
-
-    return response
-
-async def _async_get_terms_for_glossary(self, glossary_guid: str, 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
-    ----------
-        glossary_guid : str
-            Unique identifier for the glossary
-
-        effective_time : str, optional
-            If specified, terms are potentially included if they are active at the`effective_time.
-            Time format is "YYYY-MM-DDTHH:MM:SS" (ISO 8601)`
-        start_from: int, optional defaults to 0
-            The page number to start retrieving elements from
-        page_size : int, optional defaults to None
-            The number of elements to retrieve
-    Returns
-    -------
-    dict
-        The glossary definition associated with the glossary_guid
-
-    Raises
-    ------
-     InvalidParameterException
-         If the client passes incorrect parameters on the request - such as bad URLs or invalid values.
-     PropertyServerException
-         Raised by the server when an issue arises in processing a valid request.
-     NotAuthorizedException
-         The principle specified by the user_id does not have authorization for the requested action.
-    Notes
-    -----
-    """
+        start_from : int, optional
+            The index of the first term to retrieve. Default is 0.
+        page_size : int, optional
+            The number of terms to retrieve per page. If not provided, it will use the default page size.
+        Returns
+        -------
+        dict | str
+            A dict detailing the glossary term revision log history. If no term is found, the string
+            "No log found" will be returned.
+
+        Raises
+        ------
+        InvalidParameterException
+            If the client passes incorrect parameters on the request - such as bad URLs or invalid values.
+        PropertyServerException
+            Raised by the server when an issue arises in processing a valid request.
+        NotAuthorizedException
+            The principle specified by the user_id does not have authorization for the requested action.
+        """
 
-    validate_guid(glossary_guid)
+        if page_size is None:
+            page_size = self.page_size
 
-    if page_size is None:
-        page_size = self.page_size
+        validate_guid(term_guid)
 
-    url = (f"{self.platform_url}/servers/{self.view_server}/api/open-metadata/glossary-browser/glossaries/"
-           f"{glossary_guid}/terms/retrieve?startFrom={start_from}&pageSize={page_size}")
+        url = (f"{self.platform_url}/servers/{self.view_server}/api/open-metadata/glossary-browser/elements/"
+               f"{term_guid}/note-logs/retrieve?startFrom={start_from}&pageSize={page_size}")
 
-    if effective_time is not None:
-        body = {"effectiveTime": effective_time}
-        response = await self._async_make_request("POST", url, body)
-    else:
         response = await self._async_make_request("POST", url)
+        return response.json().get("elementList", "No log found")
 
-    return response.json().get("elementList", "No terms found")
+    def get_term_revision_logs(self, term_guid: str, start_from: int = 0, page_size=None, ) -> dict | str:
+        """Retrieve the revision log history for a term.
+        Parameters
+        ----------
+        term_guid : str
+            The GUID of the glossary term to retrieve.
 
-def get_terms_for_glossary(self, glossary_guid: str, 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
-    ----------
-        glossary_guid : str
-            Unique identifier for the glossary
+        start_from : int, optional
+            The index of the first term to retrieve. Default is 0.
+        page_size : int, optional
+            The number of terms to retrieve per page. If not provided, it will use the default page size.
+        Returns
+        -------
+        dict | str
+            A dict detailing the glossary term revision log history. If no term is found, the string
+            "No log found" will be returned.
 
-        effective_time : str, optional
-            If specified, terms are potentially returned if they are active at the `effective_time`
-            Time format is "YYYY-MM-DDTHH:MM:SS" (ISO 8601)
-        start_from: int, optional defaults to 0
-            The page number to start retrieving elements from
-        page_size : int, optional defaults to None
-            The number of elements to retrieve
-    Returns
-    -------
-    dict
-        The glossary definition associated with the glossary_guid
-
-    Raises
-    ------
-     InvalidParameterException
-         If the client passes incorrect parameters on the request - such as bad URLs or invalid values.
-     PropertyServerException
-         Raised by the server when an issue arises in processing a valid request.
-     NotAuthorizedException
-         The principle specified by the user_id does not have authorization for the requested action.
-    Notes
-    -----
-    """
-    loop = asyncio.get_event_loop()
-    response = loop.run_until_complete(
-        self._async_get_terms_for_glossary(glossary_guid, effective_time, start_from, page_size))
-
-    return response
-
-async def _async_get_term_relationships(self, term_guid: str, effective_time: str = None, start_from: int = 0,
-        page_size: int = None, ) -> list | str:
-    """This call retrieves details of the glossary terms linked to this glossary term.
-    Notice the original org 1 glossary term is linked via the "SourcedFrom" relationship..
-    Parameters
-    ----------
-        term_guid : str
-            Unique identifier for the glossary term
+        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.
+        """
 
-        effective_time : str, optional
-            If specified, term relationships are included if they are active at the `effective_time`.
-            Time format is "YYYY-MM-DDTHH:MM:SS" (ISO 8601)
-        start_from: int, optional defaults to 0
-            The page number to start retrieving elements from
-        page_size : int, optional defaults to None
-            The number of elements to retrieve
-    Returns
-    -------
-    dict
-        The glossary definition associated with the glossary_guid
-
-    Raises
-    ------
-     InvalidParameterException
-         If the client passes incorrect parameters on the request - such as bad URLs or invalid values.
-     PropertyServerException
-         Raised by the server when an issue arises in processing a valid request.
-     NotAuthorizedException
-         The principle specified by the user_id does not have authorization for the requested action.
-    Notes
-    -----
-    """
+        loop = asyncio.get_event_loop()
+        response = loop.run_until_complete(self._async_get_term_revision_logs(term_guid, start_from, page_size))
+
+        return response
 
-    validate_guid(term_guid)
+    async def _async_get_term_revision_history(self, term_revision_log_guid: str, start_from: int = 0,
+            page_size=None, ) -> dict | str:
+        """Retrieve the revision history for a glossary term. Async version.
 
-    if page_size is None:
-        page_size = self.page_size
+        Parameters
+        ----------
+        term_revision_log_guid : str
+            The GUID of the glossary term revision log to retrieve.
 
-    url = (f"{self.platform_url}/servers/{self.view_server}/api/open-metadata/glossary-browser/glossaries/terms/"
-           f"{term_guid}/related-terms?startFrom={start_from}&pageSize={page_size}")
+        start_from : int, optional
+            The index of the first term to retrieve. Default is 0.
+        page_size : int, optional
+            The number of terms to retrieve per page. If not provided, it will use the default page size.
+        Returns
+        -------
+        dict | str
+            A dict detailing the glossary term revision history.
+
+        Raises
+        ------
+        InvalidParameterException
+            If the client passes incorrect parameters on the request - such as bad URLs or invalid values.
+        PropertyServerException
+            Raised by the server when an issue arises in processing a valid request.
+        NotAuthorizedException
+            The principle specified by the user_id does not have authorization for the requested action.
+
+
+        Notes
+        -----
+        This revision history is created automatically.  The text is supplied on the update request.
+        If no text is supplied, the value "None" is show.
+        """
+
+        if page_size is None:
+            page_size = self.page_size
+
+        validate_guid(term_revision_log_guid)
+
+        url = (f"{self.platform_url}/servers/{self.view_server}/api/open-metadata/glossary-browser/note-logs/"
+               f"{term_revision_log_guid}/notes/retrieve?startFrom={start_from}&pageSize={page_size}")
 
-    if effective_time is not None:
-        body = {"effectiveTime": effective_time}
-        response = await self._async_make_request("POST", url, body)
-    else:
         response = await self._async_make_request("POST", url)
+        return response.json().get("elementList", "No logs found")
 
-    return response.json().get("elementList", "No terms found")
+    def get_term_revision_history(self, term_revision_log_guid: str, start_from: int = 0,
+            page_size=None, ) -> dict | str:
+        """Retrieve the revision history for a glossary term.
 
-def get_term_relationships(self, term_guid: str, effective_time: str = None, start_from: int = 0,
-        page_size: int = None, ) -> list | str:
-    """This call retrieves details of the glossary terms linked to this glossary term.
-    Notice the original org 1 glossary term is linked via the "SourcedFrom" relationship..
-    Parameters
-    ----------
-        term_guid : str
-            Unique identifier for the glossary term
+        Parameters
+        ----------
+        term_revision_log_guid : str
+            The GUID of the glossary term revision log to retrieve.
 
-        effective_time : str, optional
-            If specified, term relationships are included if they are active at the `effective_time`.
-            Time format is "YYYY-MM-DDTHH:MM:SS" (ISO 8601)
-        start_from: int, optional defaults to 0
-            The page number to start retrieving elements from
-        page_size : int, optional defaults to None
-            The number of elements to retrieve
-    Returns
-    -------
-    dict
-        The glossary definition associated with the glossary_guid
-
-    Raises
-    ------
-     InvalidParameterException
-         If the client passes incorrect parameters on the request - such as bad URLs or invalid values.
-     PropertyServerException
-         Raised by the server when an issue arises in processing a valid request.
-     NotAuthorizedException
-         The principle specified by the user_id does not have authorization for the requested action.
-    Notes
-    -----
-    """
-    loop = asyncio.get_event_loop()
-    response = loop.run_until_complete(
-        self._async_get_term_relationships(term_guid, effective_time, start_from, page_size))
+        start_from : int, optional
+            The index of the first term to retrieve. Default is 0.
+        page_size : int, optional
+            The number of terms to retrieve per page. If not provided, it will use the default page size.
+        Returns
+        -------
+        dict | str
+            A dict detailing the glossary term revision history.
+
+        Raises
+        ------
+        InvalidParameterException
+            If the client passes incorrect parameters on the request - such as bad URLs or invalid values.
+        PropertyServerException
+            Raised by the server when an issue arises in processing a valid request.
+        NotAuthorizedException
+            The principle specified by the user_id does not have authorization for the requested action.
 
-    return response
 
-async def _async_get_glossary_for_term(self, term_guid: str, effective_time: str = None) -> dict | str:
-    """Retrieve the glossary metadata element for the requested term.  The optional request body allows you to
-        specify that the glossary element should only be returned if it was effective at a particular time.
+        Notes
+        -----
+        This revision history is created automatically.  The text is supplied on the update request.
+        If no text is supplied, the value "None" is show.
+        """
 
-        Async Version.
-
-    Parameters
-    ----------
-    term_guid : str
-        The unique identifier for the term.
-
-    effective_time : datetime, optional
-        If specified, the term information will be retrieved if it is active at the `effective_time`.
-        Time format is "YYYY-MM-DDTHH:MM:SS" (ISO 8601)
-
-    Returns
-    -------
-    dict
-        The glossary information retrieved for the specified term.
-    Raises
-    ------
-     InvalidParameterException
-         If the client passes incorrect parameters on the request - such as bad URLs or invalid values.
-     PropertyServerException
-         Raised by the server when an issue arises in processing a valid request.
-     NotAuthorizedException
-         The principle specified by the user_id does not have authorization for the requested action.
-    Notes
-    -----
-    """
+        loop = asyncio.get_event_loop()
+        response = loop.run_until_complete(
+            self._async_get_term_revision_history(term_revision_log_guid, start_from, page_size))
 
-    validate_guid(term_guid)
+        return response
 
-    body = {
-        "class": "EffectiveTimeQueryRequestBody", "effectiveTime": effective_time,
-        }
-    url = (f"{self.platform_url}/servers/{self.view_server}/api/open-metadata/glossary-browser/glossaries/"
-           f"for-term/{term_guid}/retrieve")
 
-    response = await self._async_make_request("POST", url, body)
-    return response.json().get("element", "No glossary found")
+    def list_full_term_history(self, term_guid: str, output_type: str = "DICT") -> list | str:
+        """
+        Retrieves and formats the entire version history of a specific term in the repository.
+        The version history is either returned as a list of dictionaries or in a Markdown table
+        format.
 
-def get_glossary_for_term(self, term_guid: str, effective_time: str = None) -> dict | str:
-    """Retrieve the glossary metadata element for the requested term.  The optional request body allows you to
-        specify that the glossary element should only be returned if it was effective at a particular time.
+        The returned history includes details about the creation and update timestamps, user
+        information, and additional glossary term properties such as `displayName`,
+        `qualifiedName`, `description`, and others.
 
-        Async Version.
-
-    Parameters
-    ----------
-    term_guid : str
-        The unique identifier for the term.
-
-    effective_time : datetime, optional
-        TIf specified, the term information will be retrieved if it is active at the `effective_time`.
-        Time format is "YYYY-MM-DDTHH:MM:SS" (ISO 8601).
-
-    Returns
-    -------
-    dict
-        The glossary information retrieved for the specified term.
-    Raises
-    ------
-     InvalidParameterException
-         If the client passes incorrect parameters on the request - such as bad URLs or invalid values.
-     PropertyServerException
-         Raised by the server when an issue arises in processing a valid request.
-     NotAuthorizedException
-         The principle specified by the user_id does not have authorization for the requested action.
-    Notes
-    -----
-    """
-    loop = asyncio.get_event_loop()
-    response = loop.run_until_complete(self._async_get_glossary_for_term(term_guid, effective_time))
-    return response
-
-async def _async_get_terms_by_name(self, term: str, glossary_guid: str = None, status_filter: list = [],
-        effective_time: str = None, for_lineage: bool = False, for_duplicate_processing: bool = False,
-        start_from: int = 0, page_size: int = None, ) -> list:
-    """Retrieve glossary terms by display name or qualified name. Async Version.
-
-    Parameters
-    ----------
-    term : str
-        The term to search for in the glossaries.
-    glossary_guid : str, optional
-        The GUID of the glossary to search in. If not provided, the search will be performed in all glossaries.
-    status_filter : list, optional
-        A list of status values to filter the search results. Default is an empty list, which means no filtering.
-
-    effective_time : datetime, optional
-        If specified, the term information will be retrieved if it is active at the `effective_time`.
-        Time format is "YYYY-MM-DDTHH:MM:SS" (ISO 8601)
-    for_lineage : bool, optional
-        Flag to indicate whether the search should include lineage information. Default is False.
-    for_duplicate_processing : bool, optional
-        Flag to indicate whether the search should include duplicate processing information. Default is False.
-    start_from : int, optional
-        The index of the first term to retrieve. Default is 0.
-    page_size : int, optional
-        The number of terms to retrieve per page. If not provided, it will use the default page size.
-
-    Returns
-    -------
-    list
-        A list of terms matching the search criteria. If no terms are found, it returns the string "No terms found".
-
-    Raises
-    ------
-     InvalidParameterException
-         If the client passes incorrect parameters on the request - such as bad URLs or invalid values.
-     PropertyServerException
-         Raised by the server when an issue arises in processing a valid request.
-     NotAuthorizedException
-         The principle specified by the user_id does not have authorization for the requested action.
-    """
+        Parameter
+        ---------
+        term_guid: The unique identifier of the glossary term for which the version
+            history needs to be retrieved.
+        output_type: The format in which the history should be returned. It can be
+            either "DICT" (a list of dictionaries) or "LIST" (a Markdown table).
+            Defaults to "DICT".
 
-    if page_size is None:
-        page_size = self.page_size
-
-    validate_name(term)
-
-    for_lineage_s = str(for_lineage).lower()
-    for_duplicate_processing_s = str(for_duplicate_processing).lower()
-
-    body = {
-        "class": "GlossaryNameRequestBody", "glossaryGUID": glossary_guid, "name": term,
-        "effectiveTime": effective_time, "limitResultsByStatus": status_filter,
-        }
-    # body = body_slimmer(body)
-
-    url = (f"{self.platform_url}/servers/{self.view_server}/api/open-metadata/glossary-browser/glossaries/"
-           f"terms/by-name?startFrom={start_from}&pageSize={page_size}&"
-           f"&forLineage={for_lineage_s}&forDuplicateProcessing={for_duplicate_processing_s}")
-
-    # print(f"\n\nURL is: \n {url}\n\nBody is: \n{body}")
-
-    response = await self._async_make_request("POST", url, body)
-    return response.json().get("elementList", "No terms found")
-
-def get_terms_by_name(self, term: str, glossary_guid: str = None, status_filter: list = [],
-        effective_time: str = None, for_lineage: bool = False, for_duplicate_processing: bool = False,
-        start_from: int = 0, page_size: int = None, ) -> list:
-    """Retrieve glossary terms by display name or qualified name.
-
-    Parameters
-    ----------
-    term : str
-        The term to search for in the glossaries.
-    glossary_guid : str, optional
-        The GUID of the glossary to search in. If not provided, the search will be performed in all glossaries.
-    status_filter : list, optional
-        A list of status values to filter the search results. Default is an empty list, which means no filtering.
-
-    effective_time : datetime, optional
-        If specified, the term information will be retrieved if it is active at the `effective_time`.
-         Time format is "YYYY-MM-DDTHH:MM:SS" (ISO 8601)
-    for_lineage : bool, optional
-        Flag to indicate whether the search should include lineage information. Default is False.
-    for_duplicate_processing : bool, optional
-        Flag to indicate whether the search should include duplicate processing information. Default is False.
-    start_from : int, optional
-        The index of the first term to retrieve. Default is 0.
-    page_size : int, optional
-        The number of terms to retrieve per page. If not provided, it will use the default page size.
-
-    Returns
-    -------
-    list
-        A list of terms matching the search criteria. If no terms are found,
-        it returns the string "No terms found".
-
-    Raises
-    ------
-     InvalidParameterException
-         If the client passes incorrect parameters on the request - such as bad URLs or invalid values.
-     PropertyServerException
-         Raised by the server when an issue arises in processing a valid request.
-     NotAuthorizedException
-         The principle specified by the user_id does not have authorization for the requested action.
-    """
-    loop = asyncio.get_event_loop()
-    response = loop.run_until_complete(
-        self._async_get_terms_by_name(term, glossary_guid, status_filter, effective_time, for_lineage,
-            for_duplicate_processing, start_from, page_size, ))
-    return response
-
-async def _async_get_term_by_guid(self, term_guid: str, output_format: str = 'JSON') -> dict | str:
-    """Retrieve a term using its unique id. Async version.
-    Parameters
-    ----------
-    term_guid : str
-        The GUID of the glossary term to retrieve.
-    output_format: str, default = 'JSON'
-        Type of output to produce:
-            JSON - output standard json
-            MD - output standard markdown with no preamble
-            FORM - output markdown with a preamble for a form
-            REPORT - output markdown with a preamble for a report
+        Returns
+        -------
+        list | str: A list of dictionaries representing the version history
+            (if output_type is "DICT"), or a Markdown table of the version details
+            (if output_type is "LIST"). If no history is found, returns a string
+            message "No History Found".
+        """
+        history = self.get_term_versions(term_guid)
+        if type(history) is str:
+            return "No History Found"
+        version_history = []
+        for ver in history:
+            create_time = ver["elementHeader"]["versions"].get("createTime", "---")
+            update_time = ver["elementHeader"]["versions"].get("createTime", "---")
+            created_by = ver["elementHeader"]["versions"].get("createdBy", "---")
+            updated_by = ver["elementHeader"]["versions"].get("updatedBy", "---")
+            version = ver["elementHeader"]["versions"].get("version")
+
+            qualified_name = ver["glossaryTermProperties"].get("qualifiedName", '---')
+            display_name = ver["glossaryTermProperties"].get("displayName", '---')
+            summary = ver["glossaryTermProperties"].get("summary", '---')
+            description = ver["glossaryTermProperties"].get("description", '---')
+            examples = ver["glossaryTermProperties"].get("examples", '---')
+            usage = ver["glossaryTermProperties"].get("usage", '---')
+            version_identifier = ver["glossaryTermProperties"].get("versionIdentifier", '---')
+
+            version_history.append({
+                "version": version, "displayName": display_name, "summary": summary, "created": create_time,
+                "updated": update_time, "createdBy": created_by, "updatedBy": updated_by,
+                "qualifiedName": qualified_name, "description": description, "examples": examples, "usage": usage,
+                "versionIdentifier": version_identifier,
+                })
+        sorted_history = sorted(version_history, key=lambda i: i['version'], reverse=True)
+        if output_type == "DICT":
+            return sorted_history
+        elif output_type == "LIST":
+            # Get the headers from the keys of the first dictionary
+            headers = sorted_history[0].keys()
+
+            # Create the header row
+            header_row = " | ".join(headers)
+            separator_row = " | ".join(["---"] * len(headers))  # Markdown separator row
+
+            # Create the rows for the table
+            rows = []
+            for entry in sorted_history:
+                row = " | ".join(str(entry.get(header, "---")) for header in headers)
+                rows.append(row)
+
+            # Combine everything into a Markdown table string
+            markdown_table = f"{header_row}\n{separator_row}\n" + "\n".join(rows)
+            return markdown_table
+
+    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, start_from: int = 0,
+            page_size: int = None, output_format: str = "JSON", ) -> list | str:
+        """Retrieve the list of glossary term metadata elements that contain the search string.
 
-    Returns
-    -------
-    dict | str
-        A dict detailing the glossary term represented by the GUID. If no term is found, the string
-        "No term found" will be returned.
-
-    Raises
-    ------
-    InvalidParameterException
-        If the client passes incorrect parameters on the request - such as bad URLs or invalid values.
-    PropertyServerException
-        Raised by the server when an issue arises in processing a valid request.
-    NotAuthorizedException
-        The principle specified by the user_id does not have authorization for the requested action.
-    """
-    output_format = output_format.upper()
-    validate_guid(term_guid)
-
-    url = (f"{self.platform_url}/servers/{self.view_server}/api/open-metadata/glossary-browser/glossaries/terms/"
-           f"{term_guid}/retrieve")
-    response = await self._async_make_request("POST", url)
-    term_element = response.json().get("element", NO_TERMS_FOUND)
-    if term_element == NO_TERMS_FOUND:
-        return NO_TERMS_FOUND
-    if output_format != 'JSON':  # return a simplified markdown representation
-        return self.generate_terms_md(term_element, "GUID", output_format)
-    return response.json().get("element", NO_TERMS_FOUND)
-
-def get_term_by_guid(self, term_guid: str, output_format: str = 'JSON') -> dict | str:
-    """Retrieve a term using its unique id. Async version.
-    Parameters
-    ----------
-    term_guid : str
-        The GUID of the glossary term to retrieve.
-    output_format: str, default = 'JSON'
-        Type of output to produce:
+        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)
+
+            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.
+        output_format: str, default = 'JSON'
+          Type of output to produce:
             JSON - output standard json
             MD - output standard markdown with no preamble
             FORM - output markdown with a preamble for a form
             REPORT - output markdown with a preamble for a report
-    Returns
-    -------
-    dict | str
-        A dict detailing the glossary term represented by the GUID. If no term is found, the string
-        "No term found" will be returned.
-    Raises
-    ------
-    InvalidParameterException
-        If the client passes incorrect parameters on the request - such as bad URLs or invalid values.
-    PropertyServerException
-        Raised by the server when an issue arises in processing a valid request.
-    NotAuthorizedException
-        The principle specified by the user_id does not have authorization for the requested action.
-    """
 
-    loop = asyncio.get_event_loop()
-    response = loop.run_until_complete(self._async_get_terms_by_guid(term_guid, output_format))
-
-    return response
-
-async def _async_get_term_versions(self, term_guid: str, effective_time: str = None, from_time: str = None,
-        to_time: str = None, oldest_first: bool = False, for_lineage: bool = False,
-        for_duplicate_processing: bool = False, start_from: int = 0, page_size=max_paging_size,
-
-        ) -> list | str:
-    """Retrieve the versions of a glossary term. Async version.
-    Parameters
-    ----------
-    term_guid : str
-        The GUID of the glossary term to retrieve.
-
-    start_from : int, optional
-        The index of the first term to retrieve. Default is 0.
-    page_size : int, optional
-        The number of terms to retrieve per page. If not provided, it will use the default page size.
-    Returns
-    -------
-    list | str
-        A [dict] detailing the glossary term represented by the GUID. If no term is found, the string
-        "No term found" will be returned.
-
-    Raises
-    ------
-    InvalidParameterException
-        If the client passes incorrect parameters on the request - such as bad URLs or invalid values.
-    PropertyServerException
-        Raised by the server when an issue arises in processing a valid request.
-    NotAuthorizedException
-        The principle specified by the user_id does not have authorization for the requested action.
-
-    Args:
-        term_guid:
-        effective_time:
-        from_time:
-        to_time:
-        oldest_first:
-        for_lineage:
-        for_duplicate_processing:
-        start_from:
-        page_size:
-    """
+        Returns
+        -------
+        List | str
 
-    body = {
-        "effective_time": effective_time, "fromTime": from_time, "toTime": to_time, "forLineage": for_lineage,
-        "forDuplicateProcessing": for_duplicate_processing
-        }
-
-    oldest_first_s = str(oldest_first).lower()
-    validate_guid(term_guid)
-
-    url = (f"{self.platform_url}/servers/{self.view_server}/api/open-metadata/glossary-browser/glossaries/terms/"
-           f"{term_guid}/history?startFrom={start_from}&pageSize={page_size}&oldestFirst={oldest_first_s}&"
-           f"forDuplicateProcessing={for_duplicate_processing}&forLineage={for_lineage}")
-
-    response = await self._async_make_request("POST", url, body_slimmer(body))
-    return response.json().get("elementList", "No term found")
-
-def get_term_versions(self, term_guid: str, effective_time: str = None, from_time: str = None, to_time: str = None,
-        oldest_first: bool = False, for_lineage: bool = False, for_duplicate_processing: bool = False,
-        start_from: int = 0, page_size=max_paging_size, ) -> dict | str:
-    """Retrieve the versions of a glossary term.
-    Parameters
-    ----------
-    term_guid : str
-        The GUID of the glossary term to retrieve.
-
-    start_from : int, optional
-        The index of the first term to retrieve. Default is 0.
-    page_size : int, optional
-        The number of terms to retrieve per page. If not provided, it will use the default page size.
-    Returns
-    -------
-    [dict] | str
-        A [dict] detailing the glossary term represented by the GUID. If no term is found, the string
-        "No term found" will be returned.
-
-    Raises
-    ------
-    InvalidParameterException
-        If the client passes incorrect parameters on the request - such as bad URLs or invalid values.
-    PropertyServerException
-        Raised by the server when an issue arises in processing a valid request.
-    NotAuthorizedException
-        The principle specified by the user_id does not have authorization for the requested action.
-    """
+        A list of term definitions
 
-    loop = asyncio.get_event_loop()
-    response = loop.run_until_complete(
-        self._async_get_term_versions(term_guid, effective_time, from_time, to_time, oldest_first, for_lineage,
-                                      for_duplicate_processing, start_from, page_size))
-
-    return response
-
-async def _async_get_term_revision_logs(self, term_guid: str, start_from: int = 0, page_size=None, ) -> dict | str:
-    """Retrieve the revision log history for a term. Async version.
-    Parameters
-    ----------
-    term_guid : str
-        The GUID of the glossary term to retrieve.
-
-    start_from : int, optional
-        The index of the first term to retrieve. Default is 0.
-    page_size : int, optional
-        The number of terms to retrieve per page. If not provided, it will use the default page size.
-    Returns
-    -------
-    dict | str
-        A dict detailing the glossary term revision log history. If no term is found, the string
-        "No log found" will be returned.
-
-    Raises
-    ------
-    InvalidParameterException
-        If the client passes incorrect parameters on the request - such as bad URLs or invalid values.
-    PropertyServerException
-        Raised by the server when an issue arises in processing a valid request.
-    NotAuthorizedException
-        The principle specified by the user_id does not have authorization for the requested action.
-    """
+        Raises
+        ------
+        InvalidParameterException
+          If the client passes incorrect parameters on the request - such as bad URLs or invalid values
+        PropertyServerException
+          Raised by the server when an issue arises in processing a valid request
+        NotAuthorizedException
+          The principle specified by the user_id does not have authorization for the requested action
 
-    if page_size is None:
-        page_size = self.page_size
-
-    validate_guid(term_guid)
-
-    url = (f"{self.platform_url}/servers/{self.view_server}/api/open-metadata/glossary-browser/elements/"
-           f"{term_guid}/note-logs/retrieve?startFrom={start_from}&pageSize={page_size}")
-
-    response = await self._async_make_request("POST", url)
-    return response.json().get("elementList", "No log found")
-
-def get_term_revision_logs(self, term_guid: str, start_from: int = 0, page_size=None, ) -> dict | str:
-    """Retrieve the revision log history for a term.
-    Parameters
-    ----------
-    term_guid : str
-        The GUID of the glossary term to retrieve.
-
-    start_from : int, optional
-        The index of the first term to retrieve. Default is 0.
-    page_size : int, optional
-        The number of terms to retrieve per page. If not provided, it will use the default page size.
-    Returns
-    -------
-    dict | str
-        A dict detailing the glossary term revision log history. If no term is found, the string
-        "No log found" will be returned.
-
-    Raises
-    ------
-    InvalidParameterException
-        If the client passes incorrect parameters on the request - such as bad URLs or invalid values.
-    PropertyServerException
-        Raised by the server when an issue arises in processing a valid request.
-    NotAuthorizedException
-        The principle specified by the user_id does not have authorization for the requested action.
-    """
+        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_get_term_revision_logs(term_guid, start_from, page_size))
-
-    return response
-
-async def _async_get_term_revision_history(self, term_revision_log_guid: str, start_from: int = 0,
-        page_size=None, ) -> dict | str:
-    """Retrieve the revision history for a glossary term. Async version.
-
-    Parameters
-    ----------
-    term_revision_log_guid : str
-        The GUID of the glossary term revision log to retrieve.
-
-    start_from : int, optional
-        The index of the first term to retrieve. Default is 0.
-    page_size : int, optional
-        The number of terms to retrieve per page. If not provided, it will use the default page size.
-    Returns
-    -------
-    dict | str
-        A dict detailing the glossary term revision history.
-
-    Raises
-    ------
-    InvalidParameterException
-        If the client passes incorrect parameters on the request - such as bad URLs or invalid values.
-    PropertyServerException
-        Raised by the server when an issue arises in processing a valid request.
-    NotAuthorizedException
-        The principle specified by the user_id does not have authorization for the requested action.
-
-
-    Notes
-    -----
-    This revision history is created automatically.  The text is supplied on the update request.
-    If no text is supplied, the value "None" is show.
-    """
+        if page_size is None:
+            page_size = self.page_size
+        if effective_time is None:
+            effective_time = datetime.now().isoformat()
+        starts_with_s = str(starts_with).lower()
+        ends_with_s = str(ends_with).lower()
+        ignore_case_s = str(ignore_case).lower()
+        for_lineage_s = str(for_lineage).lower()
+        for_duplicate_processing_s = str(for_duplicate_processing).lower()
+        if search_string == "*":
+            search_string = None
 
-    if page_size is None:
-        page_size = self.page_size
-
-    validate_guid(term_revision_log_guid)
-
-    url = (f"{self.platform_url}/servers/{self.view_server}/api/open-metadata/glossary-browser/note-logs/"
-           f"{term_revision_log_guid}/notes/retrieve?startFrom={start_from}&pageSize={page_size}")
-
-    response = await self._async_make_request("POST", url)
-    return response.json().get("elementList", "No logs found")
-
-def get_term_revision_history(self, term_revision_log_guid: str, start_from: int = 0,
-        page_size=None, ) -> dict | str:
-    """Retrieve the revision history for a glossary term.
-
-    Parameters
-    ----------
-    term_revision_log_guid : str
-        The GUID of the glossary term revision log to retrieve.
-
-    start_from : int, optional
-        The index of the first term to retrieve. Default is 0.
-    page_size : int, optional
-        The number of terms to retrieve per page. If not provided, it will use the default page size.
-    Returns
-    -------
-    dict | str
-        A dict detailing the glossary term revision history.
-
-    Raises
-    ------
-    InvalidParameterException
-        If the client passes incorrect parameters on the request - such as bad URLs or invalid values.
-    PropertyServerException
-        Raised by the server when an issue arises in processing a valid request.
-    NotAuthorizedException
-        The principle specified by the user_id does not have authorization for the requested action.
-
-
-    Notes
-    -----
-    This revision history is created automatically.  The text is supplied on the update request.
-    If no text is supplied, the value "None" is show.
-    """
+        # validate_search_string(search_string)
 
-    loop = asyncio.get_event_loop()
-    response = loop.run_until_complete(
-        self._async_get_term_revision_history(term_revision_log_guid, start_from, page_size))
+        body = {
+            "class": "GlossarySearchStringRequestBody", "glossaryGUID": glossary_guid, "searchString": search_string,
+            "effectiveTime": effective_time, "limitResultsByStatus": status_filter,
+            }
 
-    return response
+        url = (f"{self.platform_url}/servers/{self.view_server}/api/open-metadata/glossary-browser/glossaries/"
+               f"terms/by-search-string?startFrom={start_from}&pageSize={page_size}&startsWith={starts_with_s}&"
+               f"endsWith={ends_with_s}&ignoreCase={ignore_case_s}&forLineage={for_lineage_s}&"
+               f"forDuplicateProcessing={for_duplicate_processing_s}")
 
+        response = await self._async_make_request("POST", url, body_slimmer(body))
+        term_elements = response.json().get("elementList", NO_TERMS_FOUND)
+        if term_elements == NO_TERMS_FOUND:
+            if output_format == 'JSON':
+                return NO_TERMS_FOUND
+            elif output_format in ['MD', 'FORM', 'REPORT', 'LIST']:
+                return "\n# No Terms found.\n"
+            elif output_format == 'DICT':
+                return None
+        if output_format != "JSON":  # return a simplified markdown representation
+            return self.generate_terms_md(term_elements, search_string, output_format)
+        return response.json().get("elementList", NO_TERMS_FOUND)
 
-def list_full_term_history(self, term_guid: str, output_type: str = "DICT") -> list | str:
-    """
-    Retrieves and formats the entire version history of a specific term in the repository.
-    The version history is either returned as a list of dictionaries or in a Markdown table
-    format.
-
-    The returned history includes details about the creation and update timestamps, user
-    information, and additional glossary term properties such as `displayName`,
-    `qualifiedName`, `description`, and others.
-
-    Parameter
-    ---------
-    term_guid: The unique identifier of the glossary term for which the version
-        history needs to be retrieved.
-    output_type: The format in which the history should be returned. It can be
-        either "DICT" (a list of dictionaries) or "LIST" (a Markdown table).
-        Defaults to "DICT".
-
-    Returns
-    -------
-    list | str: A list of dictionaries representing the version history
-        (if output_type is "DICT"), or a Markdown table of the version details
-        (if output_type is "LIST"). If no history is found, returns a string
-        message "No History Found".
-    """
-    history = self.get_term_versions(term_guid)
-    if type(history) is str:
-        return "No History Found"
-    version_history = []
-    for ver in history:
-        create_time = ver["elementHeader"]["versions"].get("createTime", "---")
-        update_time = ver["elementHeader"]["versions"].get("createTime", "---")
-        created_by = ver["elementHeader"]["versions"].get("createdBy", "---")
-        updated_by = ver["elementHeader"]["versions"].get("updatedBy", "---")
-        version = ver["elementHeader"]["versions"].get("version")
-
-        qualified_name = ver["glossaryTermProperties"].get("qualifiedName", '---')
-        display_name = ver["glossaryTermProperties"].get("displayName", '---')
-        summary = ver["glossaryTermProperties"].get("summary", '---')
-        description = ver["glossaryTermProperties"].get("description", '---')
-        examples = ver["glossaryTermProperties"].get("examples", '---')
-        usage = ver["glossaryTermProperties"].get("usage", '---')
-        version_identifier = ver["glossaryTermProperties"].get("versionIdentifier", '---')
-
-        version_history.append({
-            "version": version, "displayName": display_name, "summary": summary, "created": create_time,
-            "updated": update_time, "createdBy": created_by, "updatedBy": updated_by,
-            "qualifiedName": qualified_name, "description": description, "examples": examples, "usage": usage,
-            "versionIdentifier": version_identifier,
-            })
-    sorted_history = sorted(version_history, key=lambda i: i['version'], reverse=True)
-    if output_type == "DICT":
-        return sorted_history
-    elif output_type == "LIST":
-        # Get the headers from the keys of the first dictionary
-        headers = sorted_history[0].keys()
-
-        # Create the header row
-        header_row = " | ".join(headers)
-        separator_row = " | ".join(["---"] * len(headers))  # Markdown separator row
-
-        # Create the rows for the table
-        rows = []
-        for entry in sorted_history:
-            row = " | ".join(str(entry.get(header, "---")) for header in headers)
-            rows.append(row)
-
-        # Combine everything into a Markdown table string
-        markdown_table = f"{header_row}\n{separator_row}\n" + "\n".join(rows)
-        return markdown_table
-
-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, start_from: int = 0,
-        page_size: int = None, output_format: str = "JSON", ) -> 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)
-
-        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.
-    output_format: str, default = 'JSON'
-      Type of output to produce:
-        JSON - output standard json
-        MD - output standard markdown with no preamble
-        FORM - output markdown with a preamble for a form
-        REPORT - output markdown with a preamble for a report
-
-    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.
-    """
+    def find_glossary_terms(self, search_string: str, glossary_guid: str = None, status_filter: list = [],
+            effective_time: str = None, starts_with: bool = False, ends_with: bool = False, ignore_case: bool = False,
+            for_lineage: bool = False, for_duplicate_processing: bool = False, start_from: int = 0,
+            page_size: int = None, output_format: str = "JSON", ) -> list | str:
+        """Retrieve the list of glossary term metadata elements that contain the search string.
 
-    if page_size is None:
-        page_size = self.page_size
-    if effective_time is None:
-        effective_time = datetime.now().isoformat()
-    starts_with_s = str(starts_with).lower()
-    ends_with_s = str(ends_with).lower()
-    ignore_case_s = str(ignore_case).lower()
-    for_lineage_s = str(for_lineage).lower()
-    for_duplicate_processing_s = str(for_duplicate_processing).lower()
-    if search_string == "*":
-        search_string = None
-
-    # validate_search_string(search_string)
-
-    body = {
-        "class": "GlossarySearchStringRequestBody", "glossaryGUID": glossary_guid, "searchString": search_string,
-        "effectiveTime": effective_time, "limitResultsByStatus": status_filter,
-        }
-
-    url = (f"{self.platform_url}/servers/{self.view_server}/api/open-metadata/glossary-browser/glossaries/"
-           f"terms/by-search-string?startFrom={start_from}&pageSize={page_size}&startsWith={starts_with_s}&"
-           f"endsWith={ends_with_s}&ignoreCase={ignore_case_s}&forLineage={for_lineage_s}&"
-           f"forDuplicateProcessing={for_duplicate_processing_s}")
-
-    response = await self._async_make_request("POST", url, body_slimmer(body))
-    term_elements = response.json().get("elementList", NO_TERMS_FOUND)
-    if term_elements == NO_TERMS_FOUND:
-        if output_format == 'JSON':
-            return NO_TERMS_FOUND
-        elif output_format in ['MD', 'FORM', 'REPORT', 'LIST']:
-            return "\n# No Terms found.\n"
-        elif output_format == 'DICT':
-            return None
-    if output_format != "JSON":  # return a simplified markdown representation
-        return self.generate_terms_md(term_elements, search_string, output_format)
-    return response.json().get("elementList", NO_TERMS_FOUND)
-
-def find_glossary_terms(self, search_string: str, glossary_guid: str = None, status_filter: list = [],
-        effective_time: str = None, starts_with: bool = False, ends_with: bool = False, ignore_case: bool = False,
-        for_lineage: bool = False, for_duplicate_processing: bool = False, start_from: int = 0,
-        page_size: int = None, output_format: str = "JSON", ) -> 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)
-
-        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.
-    output_format: str, default = 'JSON'
-        Type of output to produce:
-        JSON - output standard json
-        MD - output standard markdown with no preamble
-        FORM - output markdown with a preamble for a form
-        REPORT - output markdown with a preamble for a report
-
-    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.
-    """
+        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)
+
+            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.
+        output_format: str, default = 'JSON'
+            Type of output to produce:
+            JSON - output standard json
+            MD - output standard markdown with no preamble
+            FORM - output markdown with a preamble for a form
+            REPORT - output markdown with a preamble for a report
+
+        Returns
+        -------
+        List | str
+
+        A list of term definitions
+
+        Raises
+        ------
+        InvalidParameterException
+          If the client passes incorrect parameters on the request - such as bad URLs or invalid values
+        PropertyServerException
+          Raised by the server when an issue arises in processing a valid request
+        NotAuthorizedException
+          The principle specified by the user_id does not have authorization for the requested action
+
+        Notes
+        -----
+        The search string is located in the request body and is interpreted as a plain string.
+        The request parameters, startsWith, endsWith and ignoreCase can be used to allow a fuzzy search.
+        The request body also supports the specification of a glossaryGUID to restrict the search to within a
+        single glossary.
+        """
 
-    loop = asyncio.get_event_loop()
-    response = loop.run_until_complete(
-        self._async_find_glossary_terms(search_string, glossary_guid, status_filter, effective_time, starts_with,
-            ends_with, ignore_case, for_lineage, for_duplicate_processing, start_from, page_size, output_format))
+        loop = asyncio.get_event_loop()
+        response = loop.run_until_complete(
+            self._async_find_glossary_terms(search_string, glossary_guid, status_filter, effective_time, starts_with,
+                ends_with, ignore_case, for_lineage, for_duplicate_processing, start_from, page_size, output_format))
 
-    return response
+        return response
 
-#
-#   Feedback
-#
-async def _async_get_comment(self, commemt_guid: str, effective_time: str, for_lineage: bool = False,
-        for_duplicate_processing: bool = False, ) -> dict | list:
-    """Retrieve the comment specified by the comment GUID"""
+    #
+    #   Feedback
+    #
+    async def _async_get_comment(self, commemt_guid: str, effective_time: str, for_lineage: bool = False,
+            for_duplicate_processing: bool = False, ) -> dict | list:
+        """Retrieve the comment specified by the comment GUID"""
 
-    validate_guid(commemt_guid)
+        validate_guid(commemt_guid)
 
-    if effective_time is None:
-        effective_time = datetime.now().isoformat()
+        if effective_time is None:
+            effective_time = datetime.now().isoformat()
 
-    for_lineage_s = str(for_lineage).lower()
-    for_duplicate_processing_s = str(for_duplicate_processing).lower()
+        for_lineage_s = str(for_lineage).lower()
+        for_duplicate_processing_s = str(for_duplicate_processing).lower()
 
-    body = {"effective_time": effective_time}
+        body = {"effective_time": effective_time}
 
-    url = (f"{self.platform_url}/servers/{self.view_server}/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/{self.view_server}/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}")
+        # print(f"\n\nURL is: \n {url}\n\nBody is: \n{body}")
 
-    response = await self._async_make_request("POST", url, body)
-    return response.json()
+        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,
-        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,
+            for_lineage: bool = False, for_duplicate_processing: bool = False, ) -> str:
+        """Reply to a comment"""
 
-    validate_guid(comment_guid)
-    validate_name(comment_type)
+        validate_guid(comment_guid)
+        validate_name(comment_type)
 
-    is_public_s = str(is_public).lower()
-    for_lineage_s = str(for_lineage).lower()
-    for_duplicate_processing_s = str(for_duplicate_processing).lower()
+        is_public_s = str(is_public).lower()
+        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/{self.view_server}/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/{self.view_server}/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}")
+        # print(f"\n\nURL is: \n {url}\n\nBody is: \n{body}")
 
-    response = await self._async_make_request("POST", url, body)
-    return response
+        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,
-        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,
+            is_merge_update: bool = False, for_lineage: bool = False, for_duplicate_processing: bool = False, ) -> str:
+        """Update the specified comment"""
 
-    validate_guid(comment_guid)
-    validate_name(comment_type)
+        validate_guid(comment_guid)
+        validate_name(comment_type)
 
-    is_public_s = str(is_public).lower()
-    for_lineage_s = str(for_lineage).lower()
-    for_duplicate_processing_s = str(for_duplicate_processing).lower()
+        is_public_s = str(is_public).lower()
+        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/{self.view_server}/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/{self.view_server}/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}")
+        # print(f"\n\nURL is: \n {url}\n\nBody is: \n{body}")
 
-    response = await self._async_make_request("POST", url, body)
-    return response
+        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, start_from: int = 0,
-        page_size: int = None, ):
-    """Find comments by search string"""
+    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, start_from: int = 0,
+            page_size: int = None, ):
+        """Find comments by search string"""
 
-    if page_size is None:
-        page_size = self.page_size
-    if effective_time is None:
-        effective_time = datetime.now().isoformat()
-    starts_with_s = str(starts_with).lower()
-    ends_with_s = str(ends_with).lower()
-    ignore_case_s = str(ignore_case).lower()
-    for_lineage_s = str(for_lineage).lower()
-    for_duplicate_processing_s = str(for_duplicate_processing).lower()
-    if search_string == "*":
-        search_string = None
+        if page_size is None:
+            page_size = self.page_size
+        if effective_time is None:
+            effective_time = datetime.now().isoformat()
+        starts_with_s = str(starts_with).lower()
+        ends_with_s = str(ends_with).lower()
+        ignore_case_s = str(ignore_case).lower()
+        for_lineage_s = str(for_lineage).lower()
+        for_duplicate_processing_s = str(for_duplicate_processing).lower()
+        if search_string == "*":
+            search_string = None
 
-    # validate_search_string(search_string)
+        # validate_search_string(search_string)
 
-    body = {
-        "class": "GlossarySearchStringRequestBody", "glossaryGUID": glossary_guid, "searchString": search_string,
-        "effectiveTime": effective_time, "limitResultsByStatus": status_filter,
-        }
-    # body = body_slimmer(body)
+        body = {
+            "class": "GlossarySearchStringRequestBody", "glossaryGUID": glossary_guid, "searchString": search_string,
+            "effectiveTime": effective_time, "limitResultsByStatus": status_filter,
+            }
+        # body = body_slimmer(body)
 
-    url = (f"{self.platform_url}/servers/{self.view_server}/api/open-metadata/glossary-browser/glossaries/"
-           f"terms/by-search-string?startFrom={start_from}&pageSize={page_size}&startsWith={starts_with_s}&"
-           f"endsWith={ends_with_s}&ignoreCase={ignore_case_s}&forLineage={for_lineage_s}&"
-           f"forDuplicateProcessing={for_duplicate_processing_s}")
+        url = (f"{self.platform_url}/servers/{self.view_server}/api/open-metadata/glossary-browser/glossaries/"
+               f"terms/by-search-string?startFrom={start_from}&pageSize={page_size}&startsWith={starts_with_s}&"
+               f"endsWith={ends_with_s}&ignoreCase={ignore_case_s}&forLineage={for_lineage_s}&"
+               f"forDuplicateProcessing={for_duplicate_processing_s}")
 
-    # print(f"\n\nURL is: \n {url}\n\nBody is: \n{body}")
+        # 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")
+        response = await self._async_make_request("POST", url, body)
+        return response.json().get("elementList", "No terms found")
 
 
 if __name__ == "__main__":
-    print("Main-Glosssary Browser")
+    print("Main-Glossary Browser")