pyegeria 5.3.6.2.5__py3-none-any.whl → 5.3.6.4__py3-none-any.whl

pyegeria/glossary_browser_omvs.py

@@ -15,7 +15,7 @@ import json
 from pyegeria._client import Client
 from pyegeria._validators import validate_guid, validate_name, validate_search_string
 from pyegeria.utils import body_slimmer
-from pyegeria._globals import NO_ELEMENTS_FOUND
+from pyegeria._globals import NO_ELEMENTS_FOUND, NO_CATALOGS_FOUND, NO_CATEGORIES_FOUND, NO_TERMS_FOUND
 MD_SEPERATOR = "\n---\n\n"
 
 class GlossaryBrowser(Client):
@@ -53,15 +53,61 @@ class GlossaryBrowser(Client):
 
         Client.__init__(self, view_server, platform_url, user_id, user_pwd, token)
 
-    def generate_glossaries_md(self, elements: list, search_string: str, form:bool = True)-> str:
-        if form:
-            elements_md = f"# Update Glossaries Form - created at {datetime.now().strftime('%Y-%m-%d %H:%M')}\n"
-            elements_action = "Update Glossary"
-        else:
-            elements_md = f"# Glossaries Report - created at {datetime.now().strftime('%Y-%m-%d %H:%M')}\n"
+
+    def make_preamble(self, obj_type, search_string, output_format: str = 'MD')-> tuple[str, str | None]:
+        """
+        Creates a preamble string and an elements action based on the given object type, search string,
+        and output format. The preamble provides a descriptive header based on the intent: To make a form,
+        a report, or unadorned markdwon. The elements action specifies the action to be taken on the object type.
+
+        Args:
+            obj_type: The type of object being updated or reported on (e.g., "Product", "Category").
+            search_string: The search string used to filter objects. Defaults to "All Terms" if None.
+            output_format: A format identifier determining the output structure.
+                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:
+            tuple: A tuple containing:
+                - A string representing the formatted update or report preamble.
+                - A string or None indicating the action description for the elements,
+                  depending on the output format.
+        """
+        search_string = search_string if search_string else "All Elements"
+        elements_action = "Update " + obj_type
+        if output_format == "FORM":
+            preamble = (f"\n# Update {obj_type} Form - created at {datetime.now().strftime('%Y-%m-%d %H:%M')}\n"
+                        f"\t {obj_type} found from the search string:  `{search_string}`\n\n")
+
+            return preamble, elements_action
+        elif output_format == "REPORT":
+            elements_md = (f"# {obj_type} Report - created at {datetime.now().strftime('%Y-%m-%d %H:%M')}\n"
+                           f"\t{obj_type}  found from the search string:  `{search_string}`\n\n")
             elements_action = None
-        search_string = search_string if search_string else "All Glossaries"
-        elements_md += f"Glossaries found from the search string:  `{search_string}`\n\n"
+            return elements_md, elements_action
+
+        else:
+            return "\n", elements_action
+
+    def make_md_attribute(self, attribute_name: str, attribute_value: str, output_type: str) -> str | None:
+        output = ""
+        attribute_value = attribute_value.strip() if attribute_value else None
+        attribute_title = attribute_name.title() if attribute_name else None
+        if output_type in ["FORM", "MD"]:
+            output = f"## {attribute_title}\n{attribute_value}\n\n"
+        elif output_type == "REPORT":
+            if attribute_value:
+                output = f"## {attribute_title}\n{attribute_value}\n\n"
+        return output
+
+
+    def generate_glossaries_md(self, elements: list | dict, search_string: str, output_format: str = 'MD')-> str:
+        elements_md, elements_action = self.make_preamble(obj_type="Glossary", search_string=search_string,
+                                                          output_format=output_format)
+        if isinstance(elements, dict):
+            elements = [elements]
 
         for element in elements:
             guid = element['elementHeader'].get("guid", None)
@@ -72,30 +118,28 @@ class GlossaryBrowser(Client):
             usage = properties.get("usage", None)
             qualified_name = properties.get("qualifiedName", None)
 
-            if form:
+            if output_format in ['FORM','MD']:
                 elements_md += f"# {elements_action}\n\n"
-                elements_md += f"## Glossary Name \n{display_name}\n\n"
-            else:
+                elements_md += f"## Glossary Name \n\n{display_name}\n\n"
+
+            elif output_format == 'REPORT':
                 elements_md += f"# Glossary Name: {display_name}\n\n"
+            else:
+                elements_md += f"## Glossary Name \n\n{display_name}\n\n"
 
+            elements_md += self.make_md_attribute( "description", description, output_format)
+            elements_md += self.make_md_attribute("language", language, output_format)
+            elements_md += self.make_md_attribute("usage", usage, output_format)
+            elements_md += self.make_md_attribute("qualified name", qualified_name, output_format)
+            elements_md += self.make_md_attribute("GUID", guid, output_format)
+            # elements_md += MD_SEPERATOR
 
-            elements_md += f"## Description\n{description}\n\n"
-            elements_md += f"## Language\n{language}\n\n"
-            elements_md += f"## Usage\n{usage}\n\n"
-            elements_md += f"## Qualified Name\n{qualified_name}\n\n"
-            elements_md += f"## GUID\n{guid}\n\n"
-            elements_md += MD_SEPERATOR
         return elements_md
 
-    def generate_terms_md(self, elements: list, search_string: str, form:bool = True)-> str:
-        if form:
-            elements_md = f"# Update terms Form - created at {datetime.now().strftime('%Y-%m-%d %H:%M')}\n"
-            elements_action = "Update Terms"
-        else:
-            elements_md = f"# Glossary Terms Report - created at {datetime.now().strftime('%Y-%m-%d %H:%M')}\n"
-            elements_action = None
-        search_string = search_string if search_string else "All Terms"
-        elements_md += f"Terms found from the search string:  `{search_string}`\n\n"
+    def generate_terms_md(self, elements: list | dict, search_string: str, output_format: str = 'MD') -> str:
+        elements_md, elements_action = self.make_preamble(obj_type="Term", search_string=search_string, output_format=output_format)
+        if isinstance(elements, dict):
+            elements = [elements]
 
         for element in elements:
             guid = element['elementHeader'].get("guid", None)
@@ -107,23 +151,78 @@ class GlossaryBrowser(Client):
             usage = element_properties.get("usage", None)
             pub_version = element_properties.get("publishedVersionIdentifier", None)
             qualified_name = element_properties.get("qualifiedName", None)
-            status = element['elementHeader']['classifications'][0].get('status', None)
+            status = element['elementHeader'].get('status', None)
+
+            glossary_guid = element['elementHeader'].get('classifications', [{}])[0].get('classificationProperties', {}).get('anchorGUID', None)
+            glossary_qualified_name = self.get_glossary_by_guid(glossary_guid)['glossaryProperties']['qualifiedName']
 
-            if form:
+            category_list_md = "\n"
+            category_list = self.get_categories_for_term(guid)
+            if type(category_list) is str and category_list == NO_CATEGORIES_FOUND:
+                category_list_md = ['---']
+            elif isinstance(category_list, list) and len(category_list) > 0:
+                for category in category_list:
+                    category_name = category["glossaryCategoryProperties"].get("qualifiedName", '---')
+                    category_list_md += f" {category_name}\n"
+
+            if output_format in ['FORM', 'MD']:
                 elements_md += f"# {elements_action}\n\n"
-                elements_md += f"## Term Name \n{display_name}\n\n"
-            else:
+                elements_md += f"## Term Name \n\n{display_name}\n\n"
+            elif output_format == 'REPORT':
                 elements_md += f"# Term Name: {display_name}\n\n"
+            else:
+                elements_md += f"## Term Name \n\n{display_name}\n\n"
+
+            elements_md += self.make_md_attribute("summary", summary, output_format)
+            elements_md += self.make_md_attribute("in glossary", glossary_qualified_name, output_format)
+            elements_md += self.make_md_attribute( "categories", category_list_md, output_format)
+            elements_md += self.make_md_attribute( "status", status, output_format)
+            elements_md += self.make_md_attribute( "description", description, output_format)
+            elements_md += self.make_md_attribute( "examples", examples, output_format)
+            elements_md += self.make_md_attribute("usage", usage, output_format)
+            elements_md += self.make_md_attribute("published version", pub_version, output_format)
+            elements_md += self.make_md_attribute("qualified name", qualified_name, output_format)
+            elements_md += self.make_md_attribute("GUID", guid, output_format)
+            # elements_md += MD_SEPERATOR
+
+        return elements_md
+
+    def generate_categories_md(self, elements: list | dict, search_string: str, output_format: str = 'MD')-> str:
+        elements_md, elements_action = self.make_preamble(obj_type="Categories", search_string=search_string,
+                                                          output_format=output_format)
+        if isinstance(elements, dict):
+            elements = [elements]
 
-            elements_md += f"## Status\n{status}\n\n"
-            elements_md += f"## Summary\n{summary}\n\n"
-            elements_md += f"## Description\n{description}\n\n"
-            elements_md += f"## Examples\n{examples}\n\n"
-            elements_md += f"## Usage\n{usage}\n\n"
-            elements_md += f"## Published Version\n{pub_version}\n\n"
-            elements_md += f"## Qualified Name\n{qualified_name}\n\n"
-            elements_md += f"## GUID\n{guid}\n\n"
+        for element in elements:
+            guid = element['elementHeader'].get("guid", None)
+            properties = element['glossaryCategoryProperties']
+            display_name = properties.get("displayName", None)
+            description = properties.get("description", None)
+            qualified_name = properties.get("qualifiedName", None)
+
+            classification_props = element["elementHeader"]['classifications'][0].get('classificationProperties', None)
+            glossary_qualified_name = '---'
+            if classification_props is not None:
+                glossary_guid = classification_props.get('anchorGUID', '---')
+                glossary_qualified_name = (
+                    self.get_glossary_by_guid(glossary_guid))['glossaryProperties']['qualifiedName']
+
+            if output_format in ['FORM', 'MD']:
+                elements_md += f"# {elements_action}\n\n"
+                elements_md += f"## Category Name \n\n{display_name}\n\n"
+
+            elif output_format == 'REPORT':
+                elements_md += f"# Category Name: {display_name}\n\n"
+            else:
+                elements_md += f"## Category Name \n\n{display_name}\n\n"
+
+
+            elements_md += self.make_md_attribute("description", description, output_format)
+            elements_md += self.make_md_attribute("in glossary", glossary_qualified_name, output_format)
+            elements_md += self.make_md_attribute("qualified name", qualified_name, output_format)
+            elements_md += self.make_md_attribute("GUID", guid, output_format)
             elements_md += MD_SEPERATOR
+
         return elements_md
 
     #
@@ -267,8 +366,7 @@ class GlossaryBrowser(Client):
         type_name: str = None,
         start_from: int = 0,
         page_size: int = None,
-        md: bool = False,
-        form: bool = True
+        output_format: str = 'JSON'
     ) -> list | str:
         """Retrieve the list of glossary metadata elements that contain the search string. Async version.
             The search string is located in the request body and is interpreted as a plain string.
@@ -301,11 +399,12 @@ class GlossaryBrowser(Client):
         page_size: int, [default=None]
             The number of items to return in a single page. If not specified, the default will be taken from
             the class instance.
-        md: bool, [default=False]
-            If true, a simplified markdown representation of the glossary will be returned
-        form: bool, [default=True]
-            If true and md is true, a form for the glossaries will be returned as a markdown string.
-            If false and md is true, a report for the glossaries will be returned.
+        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
         -------
@@ -353,14 +452,15 @@ class GlossaryBrowser(Client):
             f"forDuplicateProcessing={for_duplicate_processing_s}"
         )
 
-        response = await self._async_make_request("POST", url, body)
-        glossary_elements = response.json().get("elementList", NO_GLOSSARIES_FOUND)
-        if glossary_elements == NO_GLOSSARIES_FOUND:
+        response = await self._async_make_request("POST", url, body_slimmer(body))
+        element = response.json().get("elementList", NO_GLOSSARIES_FOUND)
+        if element == NO_GLOSSARIES_FOUND:
             return NO_GLOSSARIES_FOUND
-        if md: # return a simplified markdown representation
-            return self.generate_glossaries_md(glossary_elements, search_string,form)
+        if output_format != 'JSON':  # return a simplified markdown representation
+            return self.generate_glossaries_md(element, search_string, output_format)
         return response.json().get("elementList", NO_GLOSSARIES_FOUND)
 
+
     def find_glossaries(
         self,
         search_string: str,
@@ -373,8 +473,7 @@ class GlossaryBrowser(Client):
         type_name: str = None,
         start_from: int = 0,
         page_size: int = None,
-        md: bool = False,
-        form: bool = True
+        output_format: str = "JSON"
     ) -> list | str:
         """Retrieve the list of glossary metadata elements that contain the search string.
                 The search string is located in the request body and is interpreted as a plain string.
@@ -408,11 +507,12 @@ class GlossaryBrowser(Client):
          page_size: int, [default=None]
              The number of items to return in a single page. If not specified, the default will be taken from
              the class instance.
-        md: bool, [default=False]
-            If true, a simplified markdown representation of the glossary will be returned
-        form: bool, [default=True]
-            If true and md is true, a form for the glossaries will be returned as a markdown string.
-            If false and md is true, a report for the glossaries will be returned.
+         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
@@ -443,15 +543,14 @@ class GlossaryBrowser(Client):
                 type_name,
                 start_from,
                 page_size,
-                md,
-                form
+                output_format
             )
         )
 
         return response
 
     async def _async_get_glossary_by_guid(
-        self, glossary_guid: str, effective_time: str = None
+        self, glossary_guid: str, effective_time: str = None, output_format: str = "JSON"
     ) -> dict:
         """Retrieves information about a glossary
         Parameters
@@ -461,6 +560,13 @@ class GlossaryBrowser(Client):
             effective_time: str, optional
                 Effective time of the query. If not specified will default to any time. Time format is
                 "YYYY-MM-DDTHH:MM:SS" (ISO 8601)
+            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
@@ -477,22 +583,28 @@ class GlossaryBrowser(Client):
         Notes
         -----
         """
-
+        output_format = output_format.upper()
         validate_guid(glossary_guid)
 
         body = {
             "class": "EffectiveTimeQueryRequestBody",
-            "effectiveTime": effective_time
+            "effectiveTime" : effective_time
         }
         url = (
             f"{self.platform_url}/servers/{self.view_server}/api/open-metadata/glossary-browser/glossaries/"
             f"{glossary_guid}/retrieve"
         )
-        response = await self._async_make_request("POST", url, body)
+        response = await self._async_make_request("POST", url, body_slimmer(body))
+        element = response.json().get("element", NO_GLOSSARIES_FOUND)
+        if element == NO_GLOSSARIES_FOUND:
+            return NO_GLOSSARIES_FOUND
+        if output_format != 'JSON':  # return a simplified markdown representation
+            return self.generate_glossaries_md(element, "GUID", output_format)
         return response.json().get("element", NO_GLOSSARIES_FOUND)
 
+
     def get_glossary_by_guid(
-        self, glossary_guid: str, effective_time: str = None
+        self, glossary_guid: str, effective_time: str = None, output_format: str = "JSON"
     ) -> dict:
         """Retrieves information about a glossary
         Parameters
@@ -502,6 +614,12 @@ class GlossaryBrowser(Client):
             effective_time: str, optional
                 Effective time of the query. If not specified will default to any time. Time format is
                 "YYYY-MM-DDTHH:MM:SS" (ISO 8601)
+            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
         -------
@@ -521,7 +639,7 @@ class GlossaryBrowser(Client):
         """
         loop = asyncio.get_event_loop()
         response = loop.run_until_complete(
-            self._async_get_glossary_by_guid(glossary_guid, effective_time)
+            self._async_get_glossary_by_guid(glossary_guid, effective_time, output_format)
         )
         return response
 
@@ -738,6 +856,7 @@ class GlossaryBrowser(Client):
         ignore_case: bool = False,
         start_from: int = 0,
         page_size: int = None,
+        output_format: str = "JSON"
     ) -> list | str:
         """Retrieve the list of glossary category metadata elements that contain the search string.
             The search string is located in the request body and is interpreted as a plain string.
@@ -765,6 +884,13 @@ class GlossaryBrowser(Client):
         page_size: int, [default=None]
             The number of items to return in a single page. If not specified, the default will be taken from
             the class instance.
+        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
@@ -799,17 +925,25 @@ class GlossaryBrowser(Client):
             "searchString": search_string,
             "effectiveTime": effective_time,
         }
-        body = body_slimmer(body)
 
         url = (
             f"{self.platform_url}/servers/{self.view_server}/api/open-metadata/glossary-browser/glossaries/"
             f"categories/by-search-string?startFrom={start_from}&pageSize={page_size}&startsWith={starts_with_s}&"
             f"endsWith={ends_with_s}&ignoreCase={ignore_case_s}"
         )
-
-        response = await self._async_make_request("POST", url, body)
+        response = await self._async_make_request("POST", url, body_slimmer(body))
+        element = response.json().get("elementList", NO_CATEGORIES_FOUND)
+        if element == NO_CATEGORIES_FOUND:
+            return NO_CATEGORIES_FOUND
+        if output_format != 'JSON':  # return a simplified markdown representation
+            return self.generate_categories_md(element, search_string, output_format)
         return response.json().get("elementList", NO_CATEGORIES_FOUND)
 
+
+
+
+
+
     def find_glossary_categories(
         self,
         search_string: str,
@@ -819,6 +953,7 @@ class GlossaryBrowser(Client):
         ignore_case: bool = False,
         start_from: int = 0,
         page_size: int = None,
+        output_format: str = "JSON"
     ) -> list | str:
         """Retrieve the list of glossary category metadata elements that contain the search string.
          The search string is located in the request body and is interpreted as a plain string.
@@ -841,11 +976,18 @@ class GlossaryBrowser(Client):
             Ends with the supplied string
         ignore_case : bool, [default=False], optional
             Ignore case when searching
-         start_from: int, [default=0], optional
+        start_from: int, [default=0], optional
              When multiple pages of results are available, the page number to start from.
-         page_size: int, [default=None]
+     page_size: int, [default=None]
              The number of items to return in a single page. If not specified, the default will be taken from
              the class instance.
+        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
@@ -873,6 +1015,7 @@ class GlossaryBrowser(Client):
                 ignore_case,
                 start_from,
                 page_size,
+                output_format
             )
         )
 
@@ -1127,7 +1270,7 @@ class GlossaryBrowser(Client):
         }
 
         response = await self._async_make_request("POST", url, body)
-        return response.json().get("elementList", "No Categories found")
+        return response.json().get("elementList", NO_CATEGORIES_FOUND)
 
     def get_categories_by_name(
         self,
@@ -1186,6 +1329,7 @@ class GlossaryBrowser(Client):
         self,
         glossary_category_guid: str,
         effective_time: str = None,
+        output_format: str = 'JSON',
     ) -> list | str:
         """Retrieve the requested glossary category metadata element.  The optional request body contain an effective
         time for the query..
@@ -1200,7 +1344,12 @@ class GlossaryBrowser(Client):
             If specified, the category should only be returned if it was effective at the specified time.
             Time format is "YYYY-MM-DDTHH:MM:SS" (ISO 8601)
 
-            If not provided, the server name associated with the instance is 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
         -------
@@ -1219,7 +1368,7 @@ class GlossaryBrowser(Client):
           The principle specified by the user_id does not have authorization for the requested action
 
         """
-
+        output_format = output_format.upper()
         url = (
             f"{self.platform_url}/servers/{self.view_server}/api/open-metadata/glossary-browser/glossaries/categories/"
             f"{glossary_category_guid}/retrieve"
@@ -1230,13 +1379,19 @@ class GlossaryBrowser(Client):
             "effectiveTime": effective_time,
         }
 
-        response = await self._async_make_request("POST", url, body)
-        return response.json().get("element", "No Category found")
+        response = await self._async_make_request("POST", url, body_slimmer(body))
+        element = response.json().get("element", NO_CATEGORIES_FOUND)
+        if element == NO_CATEGORIES_FOUND:
+            return NO_CATEGORIES_FOUND
+        if output_format != 'JSON':  # return a simplified markdown representation
+            return self.generate_categories_md(element, "GUID", output_format)
+        return response.json().get("element", NO_CATEGORIES_FOUND)
 
     def get_categories_by_guid(
         self,
         glossary_category_guid: str,
         effective_time: str = None,
+        output_format: str = 'JSON',
     ) -> list | str:
         """Retrieve the requested glossary category metadata element.  The optional request body contain an effective
         time for the query..
@@ -1249,7 +1404,12 @@ class GlossaryBrowser(Client):
             If specified, the category should only be returned if it was effective at the specified time.
             Time format is "YYYY-MM-DDTHH:MM:SS" (ISO 8601)
 
-            If not provided, the server name associated with the instance is 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
         -------
@@ -1270,7 +1430,7 @@ class GlossaryBrowser(Client):
         """
         loop = asyncio.get_event_loop()
         response = loop.run_until_complete(
-            self._async_get_categories_by_guid(glossary_category_guid, effective_time)
+            self._async_get_categories_by_guid(glossary_category_guid, effective_time, output_format)
         )
         return response
 
@@ -1390,7 +1550,6 @@ class GlossaryBrowser(Client):
         ----------
             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)
@@ -1400,7 +1559,7 @@ class GlossaryBrowser(Client):
                 The number of elements to retrieve
         Returns
         -------
-        dict
+        [dict]
             The glossary definition associated with the glossary_guid
 
         Raises
@@ -1411,8 +1570,7 @@ class GlossaryBrowser(Client):
              Raised by the server when an issue arises in processing a valid request.
          NotAuthorizedException
              The principle specified by the user_id does not have authorization for the requested action.
-        Notes
-        -----
+
         """
 
         validate_guid(glossary_category_guid)
@@ -1421,7 +1579,7 @@ class GlossaryBrowser(Client):
             page_size = self.page_size
 
         url = (
-            f"{self.platform_url}/servers/{self.view_server}/api/open-metadata/glossary-browser/glossaries/terms/"
+            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}"
         )
 
@@ -1915,13 +2073,18 @@ class GlossaryBrowser(Client):
         )
         return response
 
-    async def _async_get_terms_by_guid(self, term_guid: str) -> dict | str:
+    async def _async_get_terms_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
         -------
@@ -1938,31 +2101,39 @@ class GlossaryBrowser(Client):
         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)
-        return response.json().get("element", "No term found")
+        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_terms_by_guid(self, term_guid: str) -> dict | str:
+    def get_terms_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
@@ -1974,7 +2145,7 @@ class GlossaryBrowser(Client):
         """
 
         loop = asyncio.get_event_loop()
-        response = loop.run_until_complete(self._async_get_terms_by_guid(term_guid))
+        response = loop.run_until_complete(self._async_get_terms_by_guid(term_guid, output_format))
 
         return response
 
@@ -2257,8 +2428,7 @@ class GlossaryBrowser(Client):
         for_duplicate_processing: bool = False,
         start_from: int = 0,
         page_size: int = None,
-        md: bool = False,
-        form: bool = True,
+        output_format: str = "JSON",
     ) -> list | str:
         """Retrieve the list of glossary term metadata elements that contain the search string.
 
@@ -2290,11 +2460,12 @@ class GlossaryBrowser(Client):
             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.
-        md: bool, [default=False]
-            If true, a simplified markdown representation of the glossary will be returned
-        form: bool, [default=True]
-            If true and md is true, a form for the glossaries will be returned as a markdown string.
-            If false and md is true, a report for the glossaries will be returned.
+        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
         -------
@@ -2340,7 +2511,6 @@ class GlossaryBrowser(Client):
             "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/"
@@ -2349,12 +2519,13 @@ class GlossaryBrowser(Client):
             f"forDuplicateProcessing={for_duplicate_processing_s}"
         )
 
-        response = await self._async_make_request("POST", url, body)
+
+        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:
             return NO_TERMS_FOUND
-        if md:  # return a simplified markdown representation
-            return self.generate_terms_md(term_elements, search_string, form)
+        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)
 
 
@@ -2371,8 +2542,7 @@ class GlossaryBrowser(Client):
         for_duplicate_processing: bool = False,
         start_from: int = 0,
         page_size: int = None,
-        md: bool = False,
-        form: bool = True,
+        output_format: str = "JSON",
     ) -> list | str:
         """Retrieve the list of glossary term metadata elements that contain the search string.
 
@@ -2405,11 +2575,12 @@ class GlossaryBrowser(Client):
             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.
-        md: bool, [default=False]
-            If true, a simplified markdown representation of the glossary will be returned
-        form: bool, [default=True]
-            If true and md is true, a form for the glossaries will be returned as a markdown string.
-            If false and md is true, a report for the glossaries will be returned.
+        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
         -------
@@ -2448,8 +2619,7 @@ class GlossaryBrowser(Client):
                 for_duplicate_processing,
                 start_from,
                 page_size,
-                md,
-                form,
+                output_format
             )
         )