pyegeria 5.3.8.3__py3-none-any.whl → 5.3.8.5__py3-none-any.whl

pyegeria/glossary_browser_omvs.py

@@ -10,14 +10,15 @@ added in subsequent versions of the glossary_omvs module.
 import asyncio
 from datetime import datetime
 
-from pyegeria import NO_GLOSSARIES_FOUND, NO_CATEGORIES_FOUND, NO_TERMS_FOUND, max_paging_size
-import json
+from pyegeria import NO_GLOSSARIES_FOUND, max_paging_size
 from pyegeria._client import Client
+from pyegeria._globals import NO_CATEGORIES_FOUND, NO_TERMS_FOUND
 from pyegeria._validators import validate_guid, validate_name, validate_search_string
 from pyegeria.utils import body_slimmer
-from pyegeria._globals import NO_ELEMENTS_FOUND, NO_CATALOGS_FOUND, NO_CATEGORIES_FOUND, NO_TERMS_FOUND
+
 MD_SEPERATOR = "\n---\n\n"
 
+
 class GlossaryBrowser(Client):
     """
     GlossaryBrowser is a class that extends the Client class. It provides methods to search and retrieve glossaries,
@@ -37,14 +38,7 @@ class GlossaryBrowser(Client):
 
     """
 
-    def __init__(
-        self,
-        view_server: str,
-        platform_url: str,
-        user_id: str,
-        user_pwd: str = None,
-        token: str = None,
-    ):
+    def __init__(self, view_server: str, platform_url: str, user_id: str, user_pwd: str = None, token: str = None, ):
         self.view_server = view_server
         self.platform_url = platform_url
         self.user_pwd = user_pwd
@@ -53,8 +47,7 @@ class GlossaryBrowser(Client):
 
         Client.__init__(self, view_server, platform_url, user_id, user_pwd, token)
 
-
-    def make_preamble(self, obj_type, search_string, output_format: str = 'MD')-> tuple[str, str | None]:
+    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,
@@ -117,7 +110,6 @@ class GlossaryBrowser(Client):
         # Replace newlines with spaces and escape pipe characters
         return text.replace("\n", " ").replace("|", "\\|")
 
-
     def _extract_glossary_properties(self, element: dict) -> dict:
         """
         Extract common properties from a glossary element.
@@ -136,18 +128,24 @@ class GlossaryBrowser(Client):
         usage = properties.get("usage", "") or ""
         qualified_name = properties.get("qualifiedName", "") or ""
 
+        categories = self.get_categories_for_glossary(guid)
+        cat_md_display = ''
+        cat_md_qn = ''
+        if type(categories) is list:
+            for category in categories:
+                cat_md_display += f"* {category['glossaryCategoryProperties'][('displayName')]}\n"
+                cat_md_qn += f"* {category['glossaryCategoryProperties'][('qualifiedName')]}\n"
+            cat_md = cat_md_display.strip()
+            cat_md_qn = cat_md_qn.strip()
+
         return {
-            'guid': guid,
-            'properties': properties,
-            'display_name': display_name,
-            'description': description,
-            'language': language,
-            'usage': usage,
-            'qualified_name': qualified_name
-        }
+            'guid': guid, 'properties': properties, 'display_name': display_name, 'description': description,
+            'language': language, 'usage': usage, 'qualified_name': qualified_name, 'categories_dn_md': cat_md_display,
+            'categories_qn_md': cat_md_qn
+            }
 
-    def _generate_entity_md(self, elements: list, elements_action: str, output_format: str, 
-                      entity_type: str, extract_properties_func, get_additional_props_func=None) -> str:
+    def _generate_entity_md(self, elements: list, elements_action: str, output_format: str, entity_type: str,
+                            extract_properties_func, get_additional_props_func=None) -> str:
         """
         Generic method to generate markdown for entities (glossaries, terms, categories).
 
@@ -170,7 +168,7 @@ class GlossaryBrowser(Client):
             # Get additional properties if function is provided
             additional_props = {}
             if get_additional_props_func:
-                additional_props = get_additional_props_func(element, props['guid'])
+                additional_props = get_additional_props_func(element, props['guid'], output_format)
 
             # Format header based on output format
             if output_format in ['FORM', 'MD']:
@@ -183,15 +181,26 @@ class GlossaryBrowser(Client):
 
             # Add common attributes
             for key, value in props.items():
+                # Skip categories_dn_md for FORM output and categories_qn_md for REPORT output
+                if key == 'categories_dn_md' and output_format == 'FORM':
+                    continue
+                if key == 'categories_qn_md' and output_format == 'REPORT':
+                    continue
                 if key not in ['guid', 'properties', 'display_name']:
-                    elements_md += self.make_md_attribute(key.replace('_', ' '), value, output_format)
+                    # Use "Categories" as the label for both categories_qn_md and categories_dn_md
+                    if key == 'categories_qn_md' and output_format == 'FORM':
+                        elements_md += self.make_md_attribute("Categories", value, output_format)
+                    elif key == 'categories_dn_md' and output_format == 'REPORT':
+                        elements_md += self.make_md_attribute("Categories", value, output_format)
+                    else:
+                        elements_md += self.make_md_attribute(key.replace('_', ' '), value, output_format)
 
             # Add additional properties
             for key, value in additional_props.items():
                 elements_md += self.make_md_attribute(key.replace('_', ' '), value, output_format)
 
             # Add GUID
-            elements_md += self.make_md_attribute("qualified name", props['qualified_name'], output_format)
+            # elements_md += self.make_md_attribute("qualified name", props['qualified_name'], output_format)
             elements_md += self.make_md_attribute("GUID", props['guid'], output_format)
 
             # Add separator if not the last element
@@ -212,16 +221,11 @@ class GlossaryBrowser(Client):
         Returns:
             str: Markdown representation
         """
-        return self._generate_entity_md(
-            elements=elements,
-            elements_action=elements_action,
-            output_format=output_format,
-            entity_type="Glossary",
-            extract_properties_func=self._extract_glossary_properties
-        )
+        return self._generate_entity_md(elements=elements, elements_action=elements_action, output_format=output_format,
+            entity_type="Glossary", extract_properties_func=self._extract_glossary_properties)
 
-    def _generate_entity_md_table(self, elements: list, search_string: str, entity_type: str, 
-                           extract_properties_func, columns: list, get_additional_props_func=None) -> str:
+    def _generate_entity_md_table(self, elements: list, search_string: str, entity_type: str, extract_properties_func,
+                                  columns: list, get_additional_props_func=None, output_format: str = 'LIST') -> str:
         """
         Generic method to generate a markdown table for entities (glossaries, terms, categories).
 
@@ -232,13 +236,18 @@ class GlossaryBrowser(Client):
             extract_properties_func: Function to extract properties from an element
             columns: List of column definitions, each containing 'name', 'key', and 'format' (optional)
             get_additional_props_func: Optional function to get additional properties
+            output_format (str): Output format (FORM, REPORT, LIST, etc.)
 
         Returns:
             str: Markdown table
         """
         # Create table header
-        elements_md = f"# {entity_type}s Table\n\n"
-        elements_md += f"{entity_type}s found from the search string: `{search_string}`\n\n"
+
+        # Handle pluralization - if entity_type ends with 'y', use 'ies' instead of 's'
+        entity_type_plural = f"{entity_type[:-1]}ies" if entity_type.endswith('y') else f"{entity_type}s"
+
+        elements_md = f"# {entity_type_plural} Table\n\n"
+        elements_md += f"{entity_type_plural} found from the search string: `{search_string}`\n\n"
 
         # Add column headers
         header_row = "| "
@@ -257,7 +266,7 @@ class GlossaryBrowser(Client):
             # Get additional properties if function is provided
             additional_props = {}
             if get_additional_props_func:
-                additional_props = get_additional_props_func(element, props['guid'])
+                additional_props = get_additional_props_func(element, props['guid'], output_format)
 
             # Build row
             row = "| "
@@ -292,24 +301,18 @@ class GlossaryBrowser(Client):
         Returns:
             str: Markdown table
         """
-        columns = [
-            {'name': 'Glossary Name', 'key': 'display_name'},
+        columns = [{'name': 'Glossary Name', 'key': 'display_name'},
             {'name': 'Qualified Name', 'key': 'qualified_name'},
             {'name': 'Language', 'key': 'language', 'format': True},
             {'name': 'Description', 'key': 'description', 'format': True},
-            {'name': 'Usage', 'key': 'usage', 'format': True}
-        ]
+            {'name': 'Usage', 'key': 'usage', 'format': True},
+            {'name': 'Categories', 'key': 'categories_dn_md', 'format': True}, ]
 
-        return self._generate_entity_md_table(
-            elements=elements,
-            search_string=search_string,
-            entity_type="Glossary",
-            extract_properties_func=self._extract_glossary_properties,
-            columns=columns
-        )
+        return self._generate_entity_md_table(elements=elements, search_string=search_string, entity_type="Glossary",
+            extract_properties_func=self._extract_glossary_properties, columns=columns)
 
-    def _generate_entity_dict(self, elements: list, extract_properties_func, get_additional_props_func=None, 
-                        include_keys=None, exclude_keys=None) -> list:
+    def _generate_entity_dict(self, elements: list, extract_properties_func, get_additional_props_func=None,
+                              include_keys=None, exclude_keys=None, output_format: str = 'DICT') -> list:
         """
         Generic method to generate a dictionary representation of entities (glossaries, terms, categories).
 
@@ -319,6 +322,7 @@ class GlossaryBrowser(Client):
             get_additional_props_func: Optional function to get additional properties
             include_keys: Optional list of keys to include in the result (if None, include all)
             exclude_keys: Optional list of keys to exclude from the result (if None, exclude none)
+            output_format (str): Output format (FORM, REPORT, DICT, etc.)
 
         Returns:
             list: List of entity dictionaries
@@ -331,7 +335,7 @@ class GlossaryBrowser(Client):
             # Get additional properties if function is provided
             additional_props = {}
             if get_additional_props_func:
-                additional_props = get_additional_props_func(element, props['guid'])
+                additional_props = get_additional_props_func(element, props['guid'], output_format)
 
             # Create entity dictionary
             entity_dict = {}
@@ -339,7 +343,8 @@ class GlossaryBrowser(Client):
             # Add properties based on include/exclude lists
             for key, value in props.items():
                 if key != 'properties':  # Skip the raw properties object
-                    if (include_keys is None or key in include_keys) and (exclude_keys is None or key not in exclude_keys):
+                    if (include_keys is None or key in include_keys) and (
+                            exclude_keys is None or key not in exclude_keys):
                         entity_dict[key] = value
 
             # Add additional properties
@@ -351,23 +356,22 @@ class GlossaryBrowser(Client):
 
         return result
 
-    def _generate_glossary_dict(self, elements: list) -> list:
+    def _generate_glossary_dict(self, elements: list, output_format: str = 'DICT') -> list:
         """
         Generate a dictionary representation of glossaries.
 
         Args:
             elements (list): List of glossary elements
+            output_format (str): Output format (FORM, REPORT, DICT, etc.)
 
         Returns:
             list: List of glossary dictionaries
         """
-        return self._generate_entity_dict(
-            elements=elements,
-            extract_properties_func=self._extract_glossary_properties,
-            exclude_keys=['properties']
-        )
+        return self._generate_entity_dict(elements=elements, extract_properties_func=self._extract_glossary_properties,
+            exclude_keys=['properties', 'categories_qn_md'], output_format=output_format)
 
-    def generate_glossaries_md(self, elements: list | dict, search_string: str, output_format: str = 'MD')-> str | list:
+    def generate_glossaries_md(self, elements: list | dict, search_string: str,
+                               output_format: str = 'MD') -> str | list:
         """
         Generate markdown or dictionary representation of glossaries.
 
@@ -384,13 +388,16 @@ class GlossaryBrowser(Client):
         if isinstance(elements, dict):
             elements = [elements]
 
+        if search_string is None or search_string == '':
+            search_string = "All"
+
         # If output format is LIST, create a markdown table
         if output_format == 'LIST':
             return self._generate_glossary_md_table(elements, search_string)
 
         # If output format is DICT, return a dictionary structure
         elif output_format == 'DICT':
-            return self._generate_glossary_dict(elements)
+            return self._generate_glossary_dict(elements, output_format)
 
         # Original implementation for other formats (MD, FORM, REPORT)
         elements_md += self._generate_glossary_md(elements, elements_action, output_format)
@@ -413,29 +420,23 @@ class GlossaryBrowser(Client):
         description = properties.get("description", "") or ""
         examples = properties.get("examples", "") or ""
         usage = properties.get("usage", "") or ""
-        pub_version = properties.get("publishfinVersionIdentifier", "") or ""
+        pub_version = properties.get("publishVersionIdentifier", "") or ""
         qualified_name = properties.get("qualifiedName", "") or ""
         status = element['elementHeader'].get('status', "") or ""
 
         return {
-            'guid': guid,
-            'properties': properties,
-            'display_name': display_name,
-            'summary': summary,
-            'description': description,
-            'examples': examples,
-            'usage': usage,
-            'pub_version': pub_version,
-            'qualified_name': qualified_name,
-            'status': status
-        }
-
-    def _get_categories_for_term(self, term_guid: str) -> tuple[list, str]:
+            'guid': guid, 'properties': properties, 'display_name': display_name, 'summary': summary,
+            'description': description, 'examples': examples, 'usage': usage, 'version identifier': pub_version,
+            'qualified_name': qualified_name, 'status': status
+            }
+
+    def _get_categories_for_term(self, term_guid: str, output_format: str = None) -> tuple[list, str]:
         """
         Get a list of categories for a given term.
 
         Args:
             term_guid (str): The GUID of the term
+            output_format (str): Output format (FORM, REPORT, LIST, etc.)
 
         Returns:
             tuple: A tuple containing:
@@ -451,7 +452,12 @@ class GlossaryBrowser(Client):
         elif isinstance(category_list, list) and len(category_list) > 0:
             first_cat = True
             for category in category_list:
-                category_name = category["glossaryCategoryProperties"].get("qualifiedName", '---')
+                # Use qualified name for FORM output, display name for REPORT and LIST output
+                if output_format in ['REPORT', 'LIST']:
+                    category_name = category["glossaryCategoryProperties"].get("displayName", '---')
+                else:
+                    category_name = category["glossaryCategoryProperties"].get("qualifiedName", '---')
+
                 if category_name:
                     category_names.append(category_name)
                 if first_cat:
@@ -464,118 +470,118 @@ class GlossaryBrowser(Client):
 
         return category_names, category_list_md
 
-    def _get_term_table_properties(self, element: dict, term_guid: str) -> dict:
+    def _get_term_table_properties(self, element: dict, term_guid: str, output_format: str = None) -> dict:
         """
         Get properties for a term table row.
 
         Args:
             element (dict): The term element
             term_guid (str): The GUID of the term
+            output_format (str): Output format (FORM, REPORT, etc.)
 
         Returns:
             dict: Dictionary of properties for the table row
         """
         # Get glossary information
-        glossary_qualified_name = self._get_glossary_name_for_element(element)
+        glossary_qualified_name = self._get_glossary_name_for_element(element, output_format)
 
         # Get categories
-        category_names, _ = self._get_categories_for_term(term_guid)
+        category_names, _ = self._get_categories_for_term(term_guid, output_format)
         categories_str = ", ".join(category_names) if category_names else "---"
 
         return {
-            'glossary': glossary_qualified_name,
-            'categories_str': categories_str
-        }
+            'glossary': glossary_qualified_name, 'categories_str': categories_str
+            }
 
-    def _generate_term_md_table(self, elements: list, search_string: str) -> str:
+    def _generate_term_md_table(self, elements: list, search_string: str, output_format: str = 'LIST') -> str:
         """
         Generate a markdown table for terms.
 
         Args:
             elements (list): List of term elements
             search_string (str): The search string used
+            output_format (str): Output format (FORM, REPORT, LIST, etc.)
 
         Returns:
             str: Markdown table
         """
-        columns = [
-            {'name': 'Term Name', 'key': 'display_name'},
-            {'name': 'Qualified Name', 'key': 'qualified_name'},
-            {'name': 'Summary', 'key': 'summary', 'format': True},
-            {'name': 'Glossary', 'key': 'glossary'},
-            {'name': 'Categories', 'key': 'categories_str', 'format': True}
-        ]
-
-        return self._generate_entity_md_table(
-            elements=elements,
-            search_string=search_string,
-            entity_type="Term",
-            extract_properties_func=self._extract_term_properties,
-            columns=columns,
-            get_additional_props_func=self._get_term_table_properties
-        )
-
-    def _get_term_dict_properties(self, element: dict, term_guid: str) -> dict:
+        columns = [{'name': 'Term Name', 'key': 'display_name'}, {'name': 'Qualified Name', 'key': 'qualified_name'},
+            {'name': 'Summary', 'key': 'summary', 'format': True}, {'name': 'Glossary', 'key': 'glossary'},
+            {'name': 'Categories', 'key': 'categories_str', 'format': True}]
+
+        # Create a wrapper function to pass output_format to _get_term_table_properties
+        def get_table_props_with_format(element, term_guid, output_format_param=None):
+            return self._get_term_table_properties(element, term_guid, output_format)
+
+        return self._generate_entity_md_table(elements=elements, search_string=search_string, entity_type="Term",
+            extract_properties_func=self._extract_term_properties, columns=columns,
+            get_additional_props_func=get_table_props_with_format)
+
+    def _get_term_dict_properties(self, element: dict, term_guid: str, output_format: str = None) -> dict:
         """
         Get additional properties for a term dictionary.
 
         Args:
             element (dict): The term element
             term_guid (str): The GUID of the term
+            output_format (str): Output format (FORM, REPORT, etc.)
 
         Returns:
             dict: Dictionary of additional properties
         """
         # Get glossary information
-        glossary_qualified_name = self._get_glossary_name_for_element(element)
+        glossary_qualified_name = self._get_glossary_name_for_element(element, output_format)
 
         # Get categories
-        category_names, _ = self._get_categories_for_term(term_guid)
+        category_names, _ = self._get_categories_for_term(term_guid, output_format)
 
         return {
-            'in_glossary': glossary_qualified_name,
-            'categories': category_names,
+            'in_glossary': glossary_qualified_name, 'categories': category_names,
             'version': element['glossaryTermProperties'].get('publishfinVersionIdentifier', '')
-        }
+            }
 
-    def _generate_term_dict(self, elements: list) -> list:
+    def _generate_term_dict(self, elements: list, output_format: str = 'DICT') -> list:
         """
         Generate a dictionary representation of terms.
 
         Args:
             elements (list): List of term elements
+            output_format (str): Output format (FORM, REPORT, DICT, etc.)
 
         Returns:
             list: List of term dictionaries
         """
-        return self._generate_entity_dict(
-            elements=elements,
-            extract_properties_func=self._extract_term_properties,
-            get_additional_props_func=self._get_term_dict_properties,
-            exclude_keys=['properties', 'pub_version']  # Exclude raw properties and pub_version (renamed to version)
-        )
 
-    def _get_term_additional_properties(self, element: dict, term_guid: str) -> dict:
+        # Create a wrapper function to pass output_format to _get_term_dict_properties
+        def get_dict_props_with_format(element, term_guid, output_format_param=None):
+            return self._get_term_dict_properties(element, term_guid, output_format)
+
+        return self._generate_entity_dict(elements=elements, extract_properties_func=self._extract_term_properties,
+            get_additional_props_func=get_dict_props_with_format, exclude_keys=['properties', 'pub_version']
+            # Exclude raw properties and pub_version (renamed to version)
+            )
+
+    def _get_term_additional_properties(self, element: dict, term_guid: str, output_format: str = None) -> dict:
         """
         Get additional properties for a term.
 
         Args:
             element (dict): The term element
             term_guid (str): The GUID of the term
+            output_format (str): Output format (FORM, REPORT, etc.)
 
         Returns:
             dict: Dictionary of additional properties
         """
         # Get glossary information
-        glossary_qualified_name = self._get_glossary_name_for_element(element)
+        glossary_qualified_name = self._get_glossary_name_for_element(element, output_format)
 
         # Get categories
-        _, category_list_md = self._get_categories_for_term(term_guid)
+        _, category_list_md = self._get_categories_for_term(term_guid, output_format)
 
         return {
-            'in_glossary': glossary_qualified_name,
-            'categories': category_list_md
-        }
+            'in_glossary': glossary_qualified_name, 'categories': category_list_md
+            }
 
     def _generate_term_md(self, elements: list, elements_action: str, output_format: str) -> str:
         """
@@ -589,14 +595,9 @@ class GlossaryBrowser(Client):
         Returns:
             str: Markdown representation
         """
-        return self._generate_entity_md(
-            elements=elements,
-            elements_action=elements_action,
-            output_format=output_format,
-            entity_type="Term",
-            extract_properties_func=self._extract_term_properties,
-            get_additional_props_func=self._get_term_additional_properties
-        )
+        return self._generate_entity_md(elements=elements, elements_action=elements_action, output_format=output_format,
+            entity_type="Term", extract_properties_func=self._extract_term_properties,
+            get_additional_props_func=self._get_term_additional_properties)
 
     def generate_terms_md(self, elements: list | dict, search_string: str, output_format: str = 'MD') -> str | list:
         """
@@ -610,28 +611,33 @@ class GlossaryBrowser(Client):
         Returns:
             str | list: Markdown string or list of dictionaries depending on output_format
         """
-        elements_md, elements_action = self.make_preamble(obj_type="Term", search_string=search_string, output_format=output_format)
+        elements_md, elements_action = self.make_preamble(obj_type="Term", search_string=search_string,
+                                                          output_format=output_format)
         if isinstance(elements, dict):
             elements = [elements]
 
-        # If output format is MD-TABLE, create a markdown table
+        if search_string is None or search_string == '':
+            search_string = "All"
+
+        # If output format is LIST, create a markdown table
         if output_format == 'LIST':
-            return self._generate_term_md_table(elements, search_string)
+            return self._generate_term_md_table(elements, search_string, output_format)
 
         # If output format is DICT, return a dictionary structure
         elif output_format == 'DICT':
-            return self._generate_term_dict(elements)
+            return self._generate_term_dict(elements, output_format)
 
         # Original implementation for other formats (MD, FORM, REPORT)
         elements_md += self._generate_term_md(elements, elements_action, output_format)
         return elements_md
 
-    def _get_parent_category_name(self, category_guid: str) -> str:
+    def _get_parent_category_name(self, category_guid: str, output_format: str = None) -> str:
         """
         Get the parent category name for a given category.
 
         Args:
             category_guid (str): The GUID of the category
+            output_format (str): Output format (FORM, REPORT, LIST, etc.)
 
         Returns:
             str: The parent category name or '---' if no parent
@@ -639,14 +645,23 @@ class GlossaryBrowser(Client):
         parent_cat = self.get_category_parent(category_guid)
         if isinstance(parent_cat, str):
             return '---'
-        return parent_cat['glossaryCategoryProperties']['qualifiedName']
 
-    def _get_subcategories_list(self, category_guid: str) -> tuple[list, str]:
+        # Return qualified name for FORM output, display name for REPORT and LIST output
+        if output_format == 'FORM':
+            return parent_cat['glossaryCategoryProperties']['qualifiedName']
+        elif output_format in ['REPORT', 'LIST']:
+            return parent_cat['glossaryCategoryProperties']['displayName']
+        else:
+            # Default to qualified name for backward compatibility
+            return parent_cat['glossaryCategoryProperties']['qualifiedName']
+
+    def _get_subcategories_list(self, category_guid: str, output_format: str = None) -> tuple[list, str]:
         """
         Get a list of subcategories for a given category.
 
         Args:
             category_guid (str): The GUID of the category
+            output_format (str): Output format (FORM, REPORT, LIST, etc.)
 
         Returns:
             tuple: A tuple containing:
@@ -660,7 +675,15 @@ class GlossaryBrowser(Client):
             subcategory_list_md = '---'
         elif isinstance(subcategories, list) and len(subcategories) > 0:
             for subcat in subcategories:
-                subcat_name = subcat["glossaryCategoryProperties"].get("qualifiedName", '')
+                # Use qualified name for FORM output, display name for REPORT and LIST output
+                if output_format == 'FORM':
+                    subcat_name = subcat["glossaryCategoryProperties"].get("qualifiedName", '')
+                elif output_format in ['REPORT', 'LIST']:
+                    subcat_name = subcat["glossaryCategoryProperties"].get("displayName", '')
+                else:
+                    # Default to qualified name for backward compatibility
+                    subcat_name = subcat["glossaryCategoryProperties"].get("qualifiedName", '')
+
                 if subcat_name:
                     subcategory_list.append(subcat_name)
             subcategory_list_md = ", ".join(subcategory_list)
@@ -669,12 +692,13 @@ class GlossaryBrowser(Client):
 
         return subcategory_list, subcategory_list_md
 
-    def _get_glossary_name_for_element(self, element: dict) -> str:
+    def _get_glossary_name_for_element(self, element: dict, output_format: str = None) -> str:
         """
         Get the glossary name for a given element.
 
         Args:
             element (dict): The element dictionary
+            output_format (str): Output format (FORM, REPORT, etc.)
 
         Returns:
             str: The glossary name or '---' if not found
@@ -683,12 +707,17 @@ class GlossaryBrowser(Client):
         if classification_props is None:
             return '---'
 
-        glossary_guid = classification_props.get('anchorGUID', '---')
+        glossary_guid = classification_props.get('anchorScopeGUID', '---')
         if glossary_guid == '---':
             return '---'
 
         glossary = self.get_glossary_by_guid(glossary_guid)
-        return glossary['glossaryProperties']['qualifiedName']
+
+        # Return display name for REPORT output, qualified name otherwise
+        if output_format == 'REPORT':
+            return glossary['glossaryProperties']['displayName']
+        else:
+            return glossary['glossaryProperties']['qualifiedName']
 
     def _extract_category_properties(self, element: dict) -> dict:
         """
@@ -707,131 +736,127 @@ class GlossaryBrowser(Client):
         qualified_name = properties.get("qualifiedName", "") or ""
 
         return {
-            'guid': guid,
-            'properties': properties,
-            'display_name': display_name,
-            'description': description,
+            'guid': guid, 'properties': properties, 'display_name': display_name, 'description': description,
             'qualified_name': qualified_name
-        }
+            }
 
-    def _get_category_table_properties(self, element: dict, category_guid: str) -> dict:
+    def _get_category_table_properties(self, element: dict, category_guid: str, output_format: str = None) -> dict:
         """
         Get properties for a category table row.
 
         Args:
             element (dict): The category element
             category_guid (str): The GUID of the category
+            output_format (str): Output format (FORM, REPORT, etc.)
 
         Returns:
             dict: Dictionary of properties for the table row
         """
         # Get parent category
-        parent_cat_md = self._get_parent_category_name(category_guid)
+        parent_cat_md = self._get_parent_category_name(category_guid, output_format)
 
         # Get subcategories
-        _, subcategory_list_md = self._get_subcategories_list(category_guid)
+        _, subcategory_list_md = self._get_subcategories_list(category_guid, output_format)
 
         return {
-            'parent_category': parent_cat_md,
-            'subcategories': subcategory_list_md
-        }
+            'parent_category': parent_cat_md, 'subcategories': subcategory_list_md
+            }
 
-    def _generate_category_md_table(self, elements: list, search_string: str) -> str:
+    def _generate_category_md_table(self, elements: list, search_string: str, output_format: str = 'LIST') -> str:
         """
         Generate a markdown table for categories.
 
         Args:
             elements (list): List of category elements
             search_string (str): The search string used
+            output_format (str): Output format (FORM, REPORT, etc.)
 
         Returns:
             str: Markdown table
         """
-        columns = [
-            {'name': 'Display Name', 'key': 'display_name'},
+        columns = [{'name': 'Display Name', 'key': 'display_name'},
             {'name': 'Description', 'key': 'description', 'format': True},
-            {'name': 'Qualified Name', 'key': 'qualified_name'},
-            {'name': 'Parent Category', 'key': 'parent_category'},
-            {'name': 'Subcategories', 'key': 'subcategories', 'format': True}
-        ]
+            {'name': 'Qualified Name', 'key': 'qualified_name'}, {'name': 'Parent Category', 'key': 'parent_category'},
+            {'name': 'Subcategories', 'key': 'subcategories', 'format': True}]
 
-        return self._generate_entity_md_table(
-            elements=elements,
-            search_string=search_string,
-            entity_type="Category",
-            extract_properties_func=self._extract_category_properties,
-            columns=columns,
-            get_additional_props_func=self._get_category_table_properties
-        )
+        # Create a wrapper function to pass output_format to _get_category_table_properties
+        def get_table_props_with_format(element, category_guid, output_format_param=None):
+            return self._get_category_table_properties(element, category_guid, output_format)
 
-    def _get_category_dict_properties(self, element: dict, category_guid: str) -> dict:
+        return self._generate_entity_md_table(elements=elements, search_string=search_string, entity_type="Category",
+            extract_properties_func=self._extract_category_properties, columns=columns,
+            get_additional_props_func=get_table_props_with_format)
+
+    def _get_category_dict_properties(self, element: dict, category_guid: str, output_format: str = None) -> dict:
         """
         Get additional properties for a category dictionary.
 
         Args:
             element (dict): The category element
             category_guid (str): The GUID of the category
+            output_format (str): Output format (FORM, REPORT, etc.)
 
         Returns:
             dict: Dictionary of additional properties
         """
         # Get parent category
-        parent_cat_md = self._get_parent_category_name(category_guid)
+        parent_cat_md = self._get_parent_category_name(category_guid, output_format)
 
         # Get subcategories
-        subcategory_list, _ = self._get_subcategories_list(category_guid)
+        subcategory_list, _ = self._get_subcategories_list(category_guid, output_format)
 
         # Get glossary information
-        glossary_qualified_name = self._get_glossary_name_for_element(element)
+        glossary_qualified_name = self._get_glossary_name_for_element(element, output_format)
 
         return {
-            'parent_category': parent_cat_md,
-            'subcategories': subcategory_list,
-            'in_glossary': glossary_qualified_name
-        }
+            'parent_category': parent_cat_md, 'subcategories': subcategory_list, 'in_glossary': glossary_qualified_name
+            }
 
-    def _generate_category_dict(self, elements: list) -> list:
+    def _generate_category_dict(self, elements: list, output_format: str = 'DICT') -> list:
         """
         Generate a dictionary representation of categories.
 
         Args:
             elements (list): List of category elements
+            output_format (str): Output format (FORM, REPORT, etc.)
 
         Returns:
             list: List of category dictionaries
         """
-        return self._generate_entity_dict(
-            elements=elements,
-            extract_properties_func=self._extract_category_properties,
-            get_additional_props_func=self._get_category_dict_properties,
-            exclude_keys=['properties']  # Exclude raw properties
-        )
 
-    def _get_category_additional_properties(self, element: dict, category_guid: str) -> dict:
+        # Create a wrapper function to pass output_format to _get_category_dict_properties
+        def get_dict_props_with_format(element, category_guid, output_format_param=None):
+            return self._get_category_dict_properties(element, category_guid, output_format)
+
+        return self._generate_entity_dict(elements=elements, extract_properties_func=self._extract_category_properties,
+            get_additional_props_func=get_dict_props_with_format, exclude_keys=['properties'],  # Exclude raw properties
+            output_format=output_format)
+
+    def _get_category_additional_properties(self, element: dict, category_guid: str, output_format: str = None) -> dict:
         """
         Get additional properties for a category.
 
         Args:
             element (dict): The category element
             category_guid (str): The GUID of the category
+            output_format (str): Output format (FORM, REPORT, etc.)
 
         Returns:
             dict: Dictionary of additional properties
         """
         # Get parent category
-        parent_cat_md = self._get_parent_category_name(category_guid)
+        parent_cat_md = self._get_parent_category_name(category_guid, output_format)
 
         # Get subcategories
-        _, subcategory_list_md = self._get_subcategories_list(category_guid)
+        _, subcategory_list_md = self._get_subcategories_list(category_guid, output_format)
 
         # Get glossary information
-        glossary_qualified_name = self._get_glossary_name_for_element(element)
+        glossary_qualified_name = self._get_glossary_name_for_element(element, output_format)
 
         return {
-            'in_glossary': glossary_qualified_name,
-            'parent_category': parent_cat_md,
+            'in_glossary': glossary_qualified_name, 'parent_category': parent_cat_md,
             'subcategories': subcategory_list_md
-        }
+            }
 
     def _generate_category_md(self, elements: list, elements_action: str, output_format: str) -> str:
         """
@@ -845,16 +870,17 @@ class GlossaryBrowser(Client):
         Returns:
             str: Markdown representation
         """
-        return self._generate_entity_md(
-            elements=elements,
-            elements_action=elements_action,
-            output_format=output_format,
-            entity_type="Category",
-            extract_properties_func=self._extract_category_properties,
-            get_additional_props_func=self._get_category_additional_properties
-        )
 
-    def generate_categories_md(self, elements: list | dict, search_string: str, output_format: str = 'MD')-> str | list:
+        # Create a wrapper function to pass output_format to _get_category_additional_properties
+        def get_additional_props_with_format(element, category_guid, output_format_param=None):
+            return self._get_category_additional_properties(element, category_guid, output_format)
+
+        return self._generate_entity_md(elements=elements, elements_action=elements_action, output_format=output_format,
+            entity_type="Category", extract_properties_func=self._extract_category_properties,
+            get_additional_props_func=get_additional_props_with_format)
+
+    def generate_categories_md(self, elements: list | dict, search_string: str,
+                               output_format: str = 'MD') -> str | list:
         """
         Generate markdown or dictionary representation of categories.
 
@@ -871,13 +897,16 @@ class GlossaryBrowser(Client):
         if isinstance(elements, dict):
             elements = [elements]
 
+        if search_string is None or search_string == '':
+            search_string = "All"
+
         # If output format is LIST, create a markdown table
         if output_format == 'LIST':
-            return self._generate_category_md_table(elements, search_string)
+            return self._generate_category_md_table(elements, search_string, output_format)
 
         # If output format is DICT, return a dictionary structure
         elif output_format == 'DICT':
-            return self._generate_category_dict(elements)
+            return self._generate_category_dict(elements, output_format)
 
         # Original implementation for other formats (MD, FORM, REPORT)
         elements_md += self._generate_category_md(elements, elements_action, output_format)
@@ -901,10 +930,8 @@ class GlossaryBrowser(Client):
 
         """
 
-        url = (
-            f"{self.platform_url}/servers/{self.view_server}"
-            f"/api/open-metadata/glossary-browser/glossaries/terms/status-list"
-        )
+        url = (f"{self.platform_url}/servers/{self.view_server}"
+               f"/api/open-metadata/glossary-browser/glossaries/terms/status-list")
 
         response = await self._async_make_request("GET", url)
         return response.json().get("statuses", [])
@@ -942,10 +969,8 @@ class GlossaryBrowser(Client):
 
         """
 
-        url = (
-            f"{self.platform_url}/servers/{self.view_server}"
-            f"/api/open-metadata/glossary-browser/glossaries/terms/relationships/status-list"
-        )
+        url = (f"{self.platform_url}/servers/{self.view_server}"
+               f"/api/open-metadata/glossary-browser/glossaries/terms/relationships/status-list")
 
         response = await self._async_make_request("GET", url)
         return response.json().get("statuses", [])
@@ -983,10 +1008,8 @@ class GlossaryBrowser(Client):
 
         """
 
-        url = (
-            f"{self.platform_url}/servers/{self.view_server}"
-            f"/api/open-metadata/glossary-browser/glossaries/terms/activity-types"
-        )
+        url = (f"{self.platform_url}/servers/{self.view_server}"
+               f"/api/open-metadata/glossary-browser/glossaries/terms/activity-types")
 
         response = await self._async_make_request("GET", url)
         return response.json().get("types", [])
@@ -1012,20 +1035,10 @@ class GlossaryBrowser(Client):
     #       Glossaries
     #
 
-    async def _async_find_glossaries(
-        self,
-        search_string: str,
-        effective_time: str = None,
-        starts_with: bool = False,
-        ends_with: bool = False,
-        ignore_case: bool = False,
-        for_lineage: bool = False,
-        for_duplicate_processing: bool = False,
-        type_name: str = None,
-        start_from: int = 0,
-        page_size: int = None,
-        output_format: str = 'JSON'
-    ) -> list | str:
+    async def _async_find_glossaries(self, search_string: str, effective_time: str = None, starts_with: bool = False,
+            ends_with: bool = False, ignore_case: bool = False, for_lineage: bool = False,
+            for_duplicate_processing: bool = False, type_name: str = None, start_from: int = 0, page_size: int = None,
+            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.
             The request parameters, startsWith, endsWith and ignoreCase can be used to allow a fuzzy search.
@@ -1096,43 +1109,34 @@ class GlossaryBrowser(Client):
             search_string = None
 
         body = {
-            "class": "SearchStringRequestBody",
-            "searchString": search_string,
-            "effectiveTime": effective_time,
+            "class": "SearchStringRequestBody", "searchString": search_string, "effectiveTime": effective_time,
             "typeName": type_name,
-        }
+            }
         body = body_slimmer(body)
 
-        url = (
-            f"{self.platform_url}/servers/{self.view_server}/api/open-metadata/glossary-browser/glossaries/"
-            f"by-search-string?startFrom={start_from}&pageSize={page_size}&startsWith={starts_with_s}&"
-            f"endsWith={ends_with_s}&ignoreCase={ignore_case_s}&forLineage={for_lineage_s}&"
-            f"forDuplicateProcessing={for_duplicate_processing_s}"
-        )
+        url = (f"{self.platform_url}/servers/{self.view_server}/api/open-metadata/glossary-browser/glossaries/"
+               f"by-search-string?startFrom={start_from}&pageSize={page_size}&startsWith={starts_with_s}&"
+               f"endsWith={ends_with_s}&ignoreCase={ignore_case_s}&forLineage={for_lineage_s}&"
+               f"forDuplicateProcessing={for_duplicate_processing_s}")
 
         response = await self._async_make_request("POST", url, body_slimmer(body))
         element = response.json().get("elementList", NO_GLOSSARIES_FOUND)
         if element == NO_GLOSSARIES_FOUND:
-            return NO_GLOSSARIES_FOUND
+            if output_format == 'JSON':
+                return NO_GLOSSARIES_FOUND
+            elif output_format in ['MD', 'FORM', 'REPORT', 'LIST']:
+                return "\n# No glossaries found.\n"
+            elif output_format == 'DICT':
+                return None
+
         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,
-        effective_time: str = None,
-        starts_with: bool = False,
-        ends_with: bool = False,
-        ignore_case: bool = False,
-        for_lineage: bool = False,
-        for_duplicate_processing: bool = False,
-        type_name: str = None,
-        start_from: int = 0,
-        page_size: int = None,
-        output_format: str = "JSON"
-    ) -> list | str:
+    def find_glossaries(self, search_string: str, effective_time: str = None, starts_with: bool = False,
+            ends_with: bool = False, ignore_case: bool = False, for_lineage: bool = False,
+            for_duplicate_processing: bool = False, type_name: str = None, start_from: int = 0, page_size: int = None,
+            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.
                 The request parameters, startsWith, endsWith and ignoreCase can be used to allow a fuzzy search.
@@ -1171,7 +1175,8 @@ class GlossaryBrowser(Client):
                 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
-                LIST - output a markdown table with columns for Glossary Name, Qualified Name, Language, Description, Usage
+                LIST - output a markdown table with columns for Glossary Name, Qualified Name, Language, Description,
+                Usage
                 DICT - output a dictionary structure containing all attributes
         Returns
         -------
@@ -1192,26 +1197,13 @@ class GlossaryBrowser(Client):
         """
         loop = asyncio.get_event_loop()
         response = loop.run_until_complete(
-            self._async_find_glossaries(
-                search_string,
-                effective_time,
-                starts_with,
-                ends_with,
-                ignore_case,
-                for_lineage,
-                for_duplicate_processing,
-                type_name,
-                start_from,
-                page_size,
-                output_format
-            )
-        )
+            self._async_find_glossaries(search_string, effective_time, starts_with, ends_with, ignore_case, for_lineage,
+                for_duplicate_processing, type_name, start_from, page_size, output_format))
 
         return response
 
-    async def _async_get_glossary_by_guid(
-        self, glossary_guid: str, effective_time: str = None, output_format: str = "JSON"
-    ) -> dict|str:
+    async def _async_get_glossary_by_guid(self, glossary_guid: str, effective_time: str = None,
+            output_format: str = "JSON") -> dict | str:
         """Retrieves information about a glossary
         Parameters
         ----------
@@ -1226,7 +1218,8 @@ class GlossaryBrowser(Client):
                 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
-                LIST - output a markdown table with columns for Glossary Name, Qualified Name, Language, Description, Usage
+                LIST - output a markdown table with columns for Glossary Name, Qualified Name, Language, Description,
+                Usage
                 DICT - output a dictionary structure containing all attributes
 
         Returns
@@ -1249,13 +1242,10 @@ class GlossaryBrowser(Client):
         validate_guid(glossary_guid)
 
         body = {
-            "class": "EffectiveTimeQueryRequestBody",
-            "effectiveTime" : effective_time
-        }
-        url = (
-            f"{self.platform_url}/servers/{self.view_server}/api/open-metadata/glossary-browser/glossaries/"
-            f"{glossary_guid}/retrieve"
-        )
+            "class": "EffectiveTimeQueryRequestBody", "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_slimmer(body))
         element = response.json().get("element", NO_GLOSSARIES_FOUND)
         if element == NO_GLOSSARIES_FOUND:
@@ -1264,10 +1254,7 @@ class GlossaryBrowser(Client):
             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, output_format: str = "JSON"
-    ) -> dict:
+    def get_glossary_by_guid(self, glossary_guid: str, effective_time: str = None, output_format: str = "JSON") -> dict:
         """Retrieves information about a glossary
         Parameters
         ----------
@@ -1282,7 +1269,8 @@ class GlossaryBrowser(Client):
                 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
-                LIST - output a markdown table with columns for Glossary Name, Qualified Name, Language, Description, Usage
+                LIST - output a markdown table with columns for Glossary Name, Qualified Name, Language, Description,
+                Usage
                 DICT - output a dictionary structure containing all attributes
 
         Returns
@@ -1303,17 +1291,11 @@ class GlossaryBrowser(Client):
         """
         loop = asyncio.get_event_loop()
         response = loop.run_until_complete(
-            self._async_get_glossary_by_guid(glossary_guid, effective_time, output_format)
-        )
+            self._async_get_glossary_by_guid(glossary_guid, effective_time, output_format))
         return response
 
-    async def _async_get_glossaries_by_name(
-        self,
-        glossary_name: str,
-        effective_time: str = None,
-        start_from: int = 0,
-        page_size: int = None,
-    ) -> dict | str:
+    async def _async_get_glossaries_by_name(self, glossary_name: str, effective_time: str = None, start_from: int = 0,
+            page_size: int = None, ) -> dict | str:
         """Retrieve the list of glossary metadata elements with an exactly matching qualified or display name.
             There are no wildcards supported on this request.
 
@@ -1359,21 +1341,14 @@ class GlossaryBrowser(Client):
         else:
             body = {"name": glossary_name, "effectiveTime": effective_time}
 
-        url = (
-            f"{self.platform_url}/servers/{self.view_server}/api/open-metadata/glossary-browser/glossaries/"
-            f"by-name?startFrom={start_from}&pageSize={page_size}"
-        )
+        url = (f"{self.platform_url}/servers/{self.view_server}/api/open-metadata/glossary-browser/glossaries/"
+               f"by-name?startFrom={start_from}&pageSize={page_size}")
 
         response = await self._async_make_request("POST", url, body)
         return response.json().get("elementList", "No glossaries found")
 
-    def get_glossaries_by_name(
-        self,
-        glossary_name: str,
-        effective_time: str = None,
-        start_from: int = 0,
-        page_size: int = None,
-    ) -> dict | str:
+    def get_glossaries_by_name(self, glossary_name: str, effective_time: str = None, start_from: int = 0,
+            page_size: int = None, ) -> dict | str:
         """Retrieve the list of glossary metadata elements with an exactly matching qualified or display name.
             There are no wildcards supported on this request.
 
@@ -1409,21 +1384,15 @@ class GlossaryBrowser(Client):
         """
         loop = asyncio.get_event_loop()
         response = loop.run_until_complete(
-            self._async_get_glossaries_by_name(
-                glossary_name, effective_time, start_from, page_size
-            )
-        )
+            self._async_get_glossaries_by_name(glossary_name, effective_time, start_from, page_size))
         return response
 
     #
     # Glossary Categories
     #
 
-    async def _async_get_glossary_for_category(
-        self,
-        glossary_category_guid: str,
-        effective_time: str = None,
-    ) -> dict | str:
+    async def _async_get_glossary_for_category(self, glossary_category_guid: str,
+            effective_time: str = None, ) -> dict | str:
         """Retrieve the glossary metadata element for the requested category.  The optional request body allows you to
         specify that the glossary element should only be returned if it was effective at a particular time.
 
@@ -1456,23 +1425,16 @@ class GlossaryBrowser(Client):
         """
 
         body = {
-            "class": "EffectiveTimeQueryRequestBody",
-            "effectiveTime": effective_time,
-        }
+            "class": "EffectiveTimeQueryRequestBody", "effectiveTime": effective_time,
+            }
 
-        url = (
-            f"{self.platform_url}/servers/{self.view_server}/api/open-metadata/glossary-browser/glossaries/"
-            f"for-category/{glossary_category_guid}/retrieve"
-        )
+        url = (f"{self.platform_url}/servers/{self.view_server}/api/open-metadata/glossary-browser/glossaries/"
+               f"for-category/{glossary_category_guid}/retrieve")
 
         response = await self._async_make_request("POST", url, body)
         return response.json().get("elementList", "No categories found")
 
-    def get_glossary_for_category(
-        self,
-        glossary_category_guid: str,
-        effective_time: str = None,
-    ) -> dict | str:
+    def get_glossary_for_category(self, glossary_category_guid: str, effective_time: str = None, ) -> dict | str:
         """Retrieve the glossary metadata element for the requested category.  The optional request body allows you to
         specify that the glossary element should only be returned if it was effective at a particular time.
 
@@ -1505,21 +1467,12 @@ class GlossaryBrowser(Client):
         """
         loop = asyncio.get_event_loop()
         response = loop.run_until_complete(
-            self._async_get_glossary_for_category(
-                glossary_category_guid, effective_time
-            )
-        )
+            self._async_get_glossary_for_category(glossary_category_guid, effective_time))
         return response
 
-    async def _async_get_glossary_subcategories(
-        self,
-        glossary_category_guid: str,
-        effective_time: str = None,
-        start_from: int = 0,
-        page_size: int = max_paging_size,
-        for_lineage: bool = False,
-        for_duplicate_processing: bool = False,
-    ) -> dict | str:
+    async def _async_get_glossary_subcategories(self, glossary_category_guid: str, effective_time: str = None,
+            start_from: int = 0, page_size: int = max_paging_size, for_lineage: bool = False,
+            for_duplicate_processing: bool = False, ) -> dict | str:
         """Glossary categories can be organized in a hierarchy. Retrieve the subcategories for the glossary category
         metadata element with the supplied unique identifier. If the requested category does not have any subcategories,
          null is returned. The optional request body contain an effective time for the query.
@@ -1561,15 +1514,13 @@ class GlossaryBrowser(Client):
         for_duplicate_processing_s = str(for_duplicate_processing).lower()
 
         body = {
-            "class": "EffectiveTimeQueryRequestBody",
-            "effectiveTime": effective_time,
-        }
+            "class": "EffectiveTimeQueryRequestBody", "effectiveTime": effective_time,
+            }
 
-        url = (
-            f"{self.platform_url}/servers/{self.view_server}/api/open-metadata/glossary-browser/glossaries/"
-            f"categories/{glossary_category_guid}/subcategories/retrieve?startFrom={start_from}&pageSize={page_size}&"
-            f"forLineage={for_lineage_s}&forDuplicateProcessing={for_duplicate_processing_s}"
-        )
+        url = (f"{self.platform_url}/servers/{self.view_server}/api/open-metadata/glossary-browser/glossaries/"
+               f"categories/{glossary_category_guid}/subcategories/retrieve?startFrom={start_from}&pageSize="
+               f"{page_size}&"
+               f"forLineage={for_lineage_s}&forDuplicateProcessing={for_duplicate_processing_s}")
         if effective_time:
             response = await self._async_make_request("POST", url, body_slimmer(body))
         else:
@@ -1577,15 +1528,9 @@ class GlossaryBrowser(Client):
 
         return response.json().get("elementList", "No categories found")
 
-    def get_glossary_subcategories(
-        self,
-        glossary_category_guid: str,
-        effective_time: str = None,
-        start_from: int = 0,
-        page_size: int = max_paging_size,
-        for_lineage: bool = False,
-        for_duplicate_processing: bool = False,
-    ) -> dict | str:
+    def get_glossary_subcategories(self, glossary_category_guid: str, effective_time: str = None, start_from: int = 0,
+            page_size: int = max_paging_size, for_lineage: bool = False,
+            for_duplicate_processing: bool = False, ) -> dict | str:
         """Glossary categories can be organized in a hierarchy. Retrieve the subcategories for the glossary category
         metadata element with the supplied unique identifier. If the requested category does not have any subcategories,
          null is returned. The optional request body contain an effective time for the query.
@@ -1625,24 +1570,13 @@ class GlossaryBrowser(Client):
         """
         loop = asyncio.get_event_loop()
         response = loop.run_until_complete(
-            self._async_get_glossary_subcategories(
-                glossary_category_guid, effective_time, start_from,
-                page_size, for_lineage, for_duplicate_processing
-            )
-        )
+            self._async_get_glossary_subcategories(glossary_category_guid, effective_time, start_from, page_size,
+                for_lineage, for_duplicate_processing))
         return response
 
-    async def _async_find_glossary_categories(
-        self,
-        search_string: str,
-        effective_time: str = None,
-        starts_with: bool = False,
-        ends_with: bool = False,
-        ignore_case: bool = False,
-        start_from: int = 0,
-        page_size: int = None,
-        output_format: str = "JSON"
-    ) -> list | str:
+    async def _async_find_glossary_categories(self, search_string: str, effective_time: str = None,
+            starts_with: bool = False, ends_with: bool = False, ignore_case: bool = False, 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.
             The request parameters, startsWith, endsWith and ignoreCase can be used to allow a fuzzy search.
@@ -1706,38 +1640,28 @@ class GlossaryBrowser(Client):
             search_string = None
 
         body = {
-            "class": "SearchStringRequestBody",
-            "searchString": search_string,
-            "effectiveTime": effective_time,
-        }
+            "class": "SearchStringRequestBody", "searchString": search_string, "effectiveTime": effective_time,
+            }
 
-        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}"
-        )
+        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_slimmer(body))
         element = response.json().get("elementList", NO_CATEGORIES_FOUND)
         if element == NO_CATEGORIES_FOUND:
-            return NO_CATEGORIES_FOUND
+            if output_format == 'JSON':
+                return NO_CATEGORIES_FOUND
+            elif output_format in ['MD', 'FORM', 'REPORT', 'LIST']:
+                return "\n# No categories found.\n"
+            elif output_format == 'DICT':
+                return None
         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,
-        effective_time: str = None,
-        starts_with: bool = False,
-        ends_with: bool = False,
-        ignore_case: bool = False,
-        start_from: int = 0,
-        page_size: int = None,
-        output_format: str = "JSON"
-    ) -> list | str:
+    def find_glossary_categories(self, search_string: str, effective_time: str = None, starts_with: bool = False,
+            ends_with: bool = False, ignore_case: bool = False, start_from: int = 0, page_size: int = None,
+            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.
          The request parameters, startsWith, endsWith and ignoreCase can be used to allow a fuzzy search.
@@ -1790,26 +1714,13 @@ class GlossaryBrowser(Client):
         """
         loop = asyncio.get_event_loop()
         response = loop.run_until_complete(
-            self._async_find_glossary_categories(
-                search_string,
-                effective_time,
-                starts_with,
-                ends_with,
-                ignore_case,
-                start_from,
-                page_size,
-                output_format
-            )
-        )
+            self._async_find_glossary_categories(search_string, effective_time, starts_with, ends_with, ignore_case,
+                start_from, page_size, output_format))
 
         return response
 
-    async def _async_get_categories_for_glossary(
-        self,
-        glossary_guid: str,
-        start_from: int = 0,
-        page_size: int = None,
-    ) -> list | str:
+    async def _async_get_categories_for_glossary(self, glossary_guid: str, start_from: int = 0,
+            page_size: int = None, ) -> list | str:
         """Return the list of categories associated with a glossary.
             Async version.
 
@@ -1845,20 +1756,14 @@ class GlossaryBrowser(Client):
         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}/categories/retrieve?startFrom={start_from}&pageSize={page_size}"
-        )
+        url = (f"{self.platform_url}/servers/{self.view_server}/api/open-metadata/glossary-browser/glossaries/"
+               f"{glossary_guid}/categories/retrieve?startFrom={start_from}&pageSize={page_size}")
 
         response = await self._async_make_request("POST", url)
         return response.json().get("elementList", "No Categories found")
 
-    def get_categories_for_glossary(
-        self,
-        glossary_guid: str,
-        start_from: int = 0,
-        page_size: int = None,
-    ) -> list | str:
+    def get_categories_for_glossary(self, glossary_guid: str, start_from: int = 0,
+            page_size: int = None, ) -> list | str:
         """Return the list of categories associated with a glossary.
 
         Parameters
@@ -1891,18 +1796,11 @@ class GlossaryBrowser(Client):
         """
         loop = asyncio.get_event_loop()
         response = loop.run_until_complete(
-            self._async_get_categories_for_glossary(
-                glossary_guid, start_from, page_size
-            )
-        )
+            self._async_get_categories_for_glossary(glossary_guid, start_from, page_size))
         return response
 
-    async def _async_get_categories_for_term(
-        self,
-        glossary_term_guid: str,
-        start_from: int = 0,
-        page_size: int = None,
-    ) -> list | str:
+    async def _async_get_categories_for_term(self, glossary_term_guid: str, start_from: int = 0,
+            page_size: int = None, ) -> list | str:
         """Return the list of categories associated with a glossary term.
             Async version.
 
@@ -1937,20 +1835,14 @@ class GlossaryBrowser(Client):
         if page_size is None:
             page_size = self.page_size
 
-        url = (
-            f"{self.platform_url}/servers/{self.view_server}/api/open-metadata/glossary-browser/glossaries/terms/"
-            f"{glossary_term_guid}/categories/retrieve?startFrom={start_from}&pageSize={page_size}"
-        )
+        url = (f"{self.platform_url}/servers/{self.view_server}/api/open-metadata/glossary-browser/glossaries/terms/"
+               f"{glossary_term_guid}/categories/retrieve?startFrom={start_from}&pageSize={page_size}")
 
         response = await self._async_make_request("POST", url)
         return response.json().get("elementList", "No Categories found")
 
-    def get_categories_for_term(
-        self,
-        glossary_term_guid: str,
-        start_from: int = 0,
-        page_size: int = None,
-    ) -> list | str:
+    def get_categories_for_term(self, glossary_term_guid: str, start_from: int = 0,
+            page_size: int = None, ) -> list | str:
         """Return the list of categories associated with a glossary term.
 
         Parameters
@@ -1982,20 +1874,11 @@ class GlossaryBrowser(Client):
         """
         loop = asyncio.get_event_loop()
         response = loop.run_until_complete(
-            self._async_get_categories_for_term(
-                glossary_term_guid, start_from, page_size
-            )
-        )
+            self._async_get_categories_for_term(glossary_term_guid, start_from, page_size))
         return response
 
-    async def _async_get_categories_by_name(
-        self,
-        name: str,
-        glossary_guid: str = None,
-        status: [str] = ["ACTIVE"],
-        start_from: int = 0,
-        page_size: int = None,
-    ) -> list | str:
+    async def _async_get_categories_by_name(self, name: str, glossary_guid: str = None, status: [str] = ["ACTIVE"],
+            start_from: int = 0, page_size: int = None, ) -> list | str:
         """Retrieve the list of glossary category metadata elements that either have the requested qualified name or
             display name. The name to search for is located in the request body and is interpreted as a plain string.
             The request body also supports the specification of a glossaryGUID to restrict the search to within a single
@@ -2042,27 +1925,18 @@ class GlossaryBrowser(Client):
 
         url = (
             f"{self.platform_url}/servers/{self.view_server}/api/open-metadata/glossary-browser/glossaries/categories/"
-            f"by-name?startFrom={start_from}&pageSize={page_size}"
-        )
+            f"by-name?startFrom={start_from}&pageSize={page_size}")
 
         body = {
-            "class": "GlossaryNameRequestBody",
-            "name": name,
-            "glossaryGUID": glossary_guid,
+            "class": "GlossaryNameRequestBody", "name": name, "glossaryGUID": glossary_guid,
             "limitResultsByStatus": status,
-        }
+            }
 
         response = await self._async_make_request("POST", url, body)
         return response.json().get("elementList", NO_CATEGORIES_FOUND)
 
-    def get_categories_by_name(
-        self,
-        name: str,
-        glossary_guid: str = None,
-        status: [str] = ["ACTIVE"],
-        start_from: int = 0,
-        page_size: int = None,
-    ) -> list | str:
+    def get_categories_by_name(self, name: str, glossary_guid: str = None, status: [str] = ["ACTIVE"],
+            start_from: int = 0, page_size: int = None, ) -> list | str:
         """Retrieve the list of glossary category metadata elements that either have the requested qualified name or
             display name. The name to search for is located in the request body and is interpreted as a plain string.
             The request body also supports the specification of a glossaryGUID to restrict the search to within a
@@ -2102,18 +1976,11 @@ class GlossaryBrowser(Client):
         """
         loop = asyncio.get_event_loop()
         response = loop.run_until_complete(
-            self._async_get_categories_by_name(
-                name, glossary_guid, status, start_from, page_size
-            )
-        )
+            self._async_get_categories_by_name(name, glossary_guid, status, start_from, page_size))
         return response
 
-    async def _async_get_categories_by_guid(
-        self,
-        glossary_category_guid: str,
-        effective_time: str = None,
-        output_format: str = 'JSON',
-    ) -> list | str:
+    async def _async_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..
 
@@ -2154,13 +2021,11 @@ class GlossaryBrowser(Client):
         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"
-        )
+            f"{glossary_category_guid}/retrieve")
 
         body = {
-            "class": "EffectiveTimeQueryRequestBody",
-            "effectiveTime": effective_time,
-        }
+            "class": "EffectiveTimeQueryRequestBody", "effectiveTime": effective_time,
+            }
 
         response = await self._async_make_request("POST", url, body_slimmer(body))
         element = response.json().get("element", NO_CATEGORIES_FOUND)
@@ -2170,12 +2035,8 @@ class GlossaryBrowser(Client):
             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:
+    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..
 
@@ -2213,15 +2074,10 @@ class GlossaryBrowser(Client):
         """
         loop = asyncio.get_event_loop()
         response = loop.run_until_complete(
-            self._async_get_categories_by_guid(glossary_category_guid, effective_time, output_format)
-        )
+            self._async_get_categories_by_guid(glossary_category_guid, effective_time, output_format))
         return response
 
-    async def _async_get_category_parent(
-        self,
-        glossary_category_guid: str,
-        effective_time: str = None,
-    ) -> list | str:
+    async def _async_get_category_parent(self, glossary_category_guid: str, effective_time: str = None, ) -> list | str:
         """Glossary categories can be organized in a hierarchy. Retrieve the parent glossary category metadata
             element for the glossary category with the supplied unique identifier.  If the requested category
             does not have a parent category, null is returned.  The optional request body contain an effective time
@@ -2259,22 +2115,16 @@ class GlossaryBrowser(Client):
 
         url = (
             f"{self.platform_url}/servers/{self.view_server}/api/open-metadata/glossary-browser/glossaries/categories/"
-            f"{glossary_category_guid}/parent/retrieve"
-        )
+            f"{glossary_category_guid}/parent/retrieve")
 
         body = {
-            "class": "EffectiveTimeQueryRequestBody",
-            "effectiveTime": effective_time,
-        }
+            "class": "EffectiveTimeQueryRequestBody", "effectiveTime": effective_time,
+            }
 
         response = await self._async_make_request("POST", url, body)
         return response.json().get("element", "No Parent Category found")
 
-    def get_category_parent(
-        self,
-        glossary_category_guid: str,
-        effective_time: str = None,
-    ) -> list | str:
+    def get_category_parent(self, glossary_category_guid: str, effective_time: str = None, ) -> list | str:
         """Glossary categories can be organized in a hierarchy. Retrieve the parent glossary category metadata
             element for the glossary category with the supplied unique identifier.  If the requested category
             does not have a parent category, null is returned.  The optional request body contain an effective time
@@ -2308,22 +2158,177 @@ class GlossaryBrowser(Client):
 
         """
         loop = asyncio.get_event_loop()
-        response = loop.run_until_complete(
-            self._async_get_category_parent(glossary_category_guid, effective_time)
-        )
+        response = loop.run_until_complete(self._async_get_category_parent(glossary_category_guid, effective_time))
         return response
 
+    def get_glossary_category_structure(self, glossary_guid: str, output_format: str = "DICT") -> dict | str:
+        """Derive the category structure of an Egeria glossary.
+
+        This method builds a hierarchical representation of the categories in a glossary,
+        showing the parent-child relationships between categories.
+
+        Parameters
+        ----------
+        glossary_guid: str
+            The unique identifier of the glossary.
+        output_format: str, default = 'DICT'
+            The format of the output:
+            - DICT: Returns a Python dictionary structure
+            - LIST: Returns a markdown table
+            - MD: Returns a markdown outline with bullets and indentations
+
+        Returns
+        -------
+        dict | str
+            If output_format is DICT, returns a dictionary structure representing the category hierarchy.
+            If output_format is LIST, returns a markdown table representing the category hierarchy.
+            If output_format is MD, returns a markdown outline with bullets and indentations.
+
+        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
+        """
+        from pyegeria._validators import validate_guid
+
+        validate_guid(glossary_guid)
+
+        # Get all categories in the glossary
+        all_categories = self.get_categories_for_glossary(glossary_guid)
+        if isinstance(all_categories, str):
+            return NO_CATEGORIES_FOUND
+
+        # Create a dictionary to store categories by GUID for quick lookup
+        categories_by_guid = {cat['elementHeader']['guid']: cat for cat in all_categories}
+
+        # Identify root categories (categories with no parent)
+        root_guids = []
+        for cat_guid in categories_by_guid.keys():
+            parent = self.get_category_parent(cat_guid)
+            if isinstance(parent, str):
+                root_guids.append(cat_guid)  # This category has no parent
+
+        # Build the category tree
+        category_tree = []
+
+        def build_category_tree(category_guid):
+            """Recursively build a category tree for a category."""
+            if category_guid not in categories_by_guid:
+                return None
+
+            category = categories_by_guid[category_guid]
+            display_name = category['glossaryCategoryProperties'].get('displayName', '---')
+            qualified_name = category['glossaryCategoryProperties'].get('qualifiedName', '---')
+            description = category['glossaryCategoryProperties'].get('description', '---')
+
+            # Get subcategories
+            subcategories = self.get_glossary_subcategories(category_guid)
+            children = []
+
+            if isinstance(subcategories, list):
+                for subcat in subcategories:
+                    subcat_guid = subcat['elementHeader']['guid']
+                    child_tree = build_category_tree(subcat_guid)
+                    if child_tree:
+                        children.append(child_tree)
+
+            # Get parent category information
+            parent_info = None
+            parent = self.get_category_parent(category_guid)
+            if not isinstance(parent, str):
+                parent_guid = parent['elementHeader']['guid']
+                parent_name = parent['glossaryCategoryProperties'].get('displayName', '---')
+                parent_info = {
+                    'guid': parent_guid,
+                    'name': parent_name
+                }
+
+            return {
+                'guid': category_guid,
+                'name': display_name,
+                'qualifiedName': qualified_name,
+                'description': description,
+                'parent': parent_info,
+                'children': children
+            }
+
+        # Build tree for each root category
+        for root_guid in root_guids:
+            tree = build_category_tree(root_guid)
+            if tree:
+                category_tree.append(tree)
+
+        # Format the output according to the specified output_format
+        if output_format == "DICT":
+            return {
+                'glossary_guid': glossary_guid,
+                'categories': category_tree
+            }
+        elif output_format == "LIST":
+            # Generate markdown table
+            md_table = "| Category | Path | Description | Parent Category | Child Categories |\n"
+            md_table += "|---------|------|-------------|----------------|------------------|\n"
+
+            def add_categories_to_table(categories, path=""):
+                nonlocal md_table
+                for category in categories:
+                    category_path = f"{path}/{category['name']}" if path else category['name']
+
+                    # Get parent category name
+                    parent_name = "None"
+                    if category['parent']:
+                        parent_name = category['parent']['name']
+
+                    # Get child categories names
+                    child_names = []
+                    for child in category['children']:
+                        child_names.append(child['name'])
+                    child_categories = ", ".join(child_names) if child_names else "None"
+
+                    md_table += f"| {category['name']} | {category_path} | {self._format_for_markdown_table(category['description'])} | {parent_name} | {child_categories} |\n"
+                    if category['children']:
+                        add_categories_to_table(category['children'], category_path)
+
+            add_categories_to_table(category_tree)
+            return md_table
+        elif output_format == "MD":
+            # Generate markdown outline with bullets and indentations
+            md_outline = f"# Category Structure for Glossary (GUID: {glossary_guid})\n\n"
+
+            def add_categories_to_outline(categories, indent_level=0):
+                nonlocal md_outline
+                for category in categories:
+                    # Add bullet with proper indentation
+                    indent = "  " * indent_level
+                    md_outline += f"{indent}- **{category['name']}**"
+
+                    # Add description if available
+                    if category['description'] and category['description'] != '---':
+                        md_outline += f": {category['description']}"
+
+                    md_outline += "\n"
+
+                    # Process children with increased indentation
+                    if category['children']:
+                        add_categories_to_outline(category['children'], indent_level + 1)
+
+            add_categories_to_outline(category_tree)
+            return md_outline
+        else:
+            return f"Unsupported output format: {output_format}. Use 'DICT', 'LIST', or 'MD'."
+
+
+
     #
     #  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:
+    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.
 
@@ -2363,8 +2368,7 @@ class GlossaryBrowser(Client):
 
         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}"
-        )
+            f"{glossary_category_guid}/terms/retrieve?startFrom={start_from}&pageSize={page_size}")
 
         if effective_time is not None:
             body = {"effectiveTime": effective_time}
@@ -2374,13 +2378,8 @@ class GlossaryBrowser(Client):
 
         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:
+    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.
 
@@ -2416,23 +2415,12 @@ class GlossaryBrowser(Client):
         """
         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,
-            )
-        )
+            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:
+    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
@@ -2469,10 +2457,8 @@ class GlossaryBrowser(Client):
         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}"
-        )
+        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}
@@ -2482,13 +2468,8 @@ class GlossaryBrowser(Client):
 
         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:
+    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
@@ -2521,20 +2502,12 @@ class GlossaryBrowser(Client):
         """
         loop = asyncio.get_event_loop()
         response = loop.run_until_complete(
-            self._async_get_terms_for_glossary(
-                glossary_guid, effective_time, start_from, page_size
-            )
-        )
+            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:
+    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
@@ -2571,10 +2544,8 @@ class GlossaryBrowser(Client):
         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}"
-        )
+        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}
@@ -2584,13 +2555,8 @@ class GlossaryBrowser(Client):
 
         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:
+    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
@@ -2623,16 +2589,11 @@ class GlossaryBrowser(Client):
         """
         loop = asyncio.get_event_loop()
         response = loop.run_until_complete(
-            self._async_get_term_relationships(
-                term_guid, effective_time, start_from, page_size
-            )
-        )
+            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:
+    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.
 
@@ -2666,20 +2627,15 @@ class GlossaryBrowser(Client):
         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"
-        )
+            "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:
+    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.
 
@@ -2710,22 +2666,12 @@ class GlossaryBrowser(Client):
         -----
         """
         loop = asyncio.get_event_loop()
-        response = loop.run_until_complete(
-            self._async_get_glossary_for_term(term_guid, effective_time)
-        )
+        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:
+    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
@@ -2773,36 +2719,23 @@ class GlossaryBrowser(Client):
         for_duplicate_processing_s = str(for_duplicate_processing).lower()
 
         body = {
-            "class": "GlossaryNameRequestBody",
-            "glossaryGUID": glossary_guid,
-            "name": term,
-            "effectiveTime": effective_time,
-            "limitResultsByStatus": status_filter,
-        }
+            "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}"
-        )
+        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:
+    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
@@ -2843,20 +2776,11 @@ class GlossaryBrowser(Client):
         """
         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,
-            )
-        )
+            self._async_get_terms_by_name(term, glossary_guid, status_filter, effective_time, for_lineage,
+                for_duplicate_processing, start_from, page_size, ))
         return response
 
-    async def _async_get_terms_by_guid(self, term_guid: str, output_format: str = 'JSON') -> dict | str:
+    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
         ----------
@@ -2887,10 +2811,8 @@ class GlossaryBrowser(Client):
         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"
-        )
+        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:
@@ -2899,8 +2821,7 @@ class GlossaryBrowser(Client):
             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, output_format: str = 'JSON') -> dict | str:
+    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
         ----------
@@ -2932,12 +2853,11 @@ class GlossaryBrowser(Client):
 
         return response
 
-    async def _async_get_terms_versions(
-        self,
-        term_guid: str,
-        start_from: int = 0,
-        page_size=None,
-    ) -> dict | str:
+    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
         ----------
@@ -2950,8 +2870,8 @@ class GlossaryBrowser(Client):
             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
+        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
@@ -2962,27 +2882,37 @@ 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.
+
+        Args:
+            term_guid:
+            effective_time:
+            from_time:
+            to_time:
+            oldest_first:
+            for_lineage:
+            for_duplicate_processing:
+            start_from:
+            page_size:
         """
 
-        if page_size is None:
-            page_size = self.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}"
-        )
+        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)
-        return response.json().get("element", "No term found")
-
-    def get_terms_versions(
-        self,
-        term_guid: str,
-        start_from: int = 0,
-        page_size=None,
-    ) -> dict | str:
+        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
         ----------
@@ -2995,8 +2925,8 @@ class GlossaryBrowser(Client):
             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
+        [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
@@ -3011,17 +2941,12 @@ class GlossaryBrowser(Client):
 
         loop = asyncio.get_event_loop()
         response = loop.run_until_complete(
-            self._async_get_terms_versions(term_guid, start_from, page_size)
-        )
+            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:
+    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
         ----------
@@ -3053,20 +2978,13 @@ class GlossaryBrowser(Client):
 
         validate_guid(term_guid)
 
-        url = (
-            f"{self.platform_url}/servers/{self.view_server}/api/open-metadata/glossary-browser/elements/"
-            f"{term_guid}/notes/retrieve?startFrom={start_from}&pageSize={page_size}"
-        )
+        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:
+    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
         ----------
@@ -3094,18 +3012,12 @@ class GlossaryBrowser(Client):
         """
 
         loop = asyncio.get_event_loop()
-        response = loop.run_until_complete(
-            self._async_get_term_revision_logs(term_guid, start_from, page_size)
-        )
+        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:
+    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
@@ -3143,20 +3055,14 @@ class GlossaryBrowser(Client):
 
         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}"
-        )
+        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:
+    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
@@ -3191,28 +3097,86 @@ class GlossaryBrowser(Client):
 
         loop = asyncio.get_event_loop()
         response = loop.run_until_complete(
-            self._async_get_term_revision_history(
-                term_revision_log_guid, start_from, page_size
-            )
-        )
+            self._async_get_term_revision_history(term_revision_log_guid, start_from, page_size))
 
         return response
 
-    async def _async_find_glossary_terms(
-        self,
-        search_string: str,
-        glossary_guid: str = None,
-        status_filter: list = [],
-        effective_time: str = None,
-        starts_with: bool = False,
-        ends_with: bool = False,
-        ignore_case: bool = False,
-        for_lineage: bool = False,
-        for_duplicate_processing: bool = False,
-        start_from: int = 0,
-        page_size: int = None,
-        output_format: str = "JSON",
-    ) -> list | str:
+
+    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
@@ -3288,45 +3252,32 @@ class GlossaryBrowser(Client):
         # 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}"
-        )
+            "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:
-            return 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:
+    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
@@ -3390,34 +3341,16 @@ class GlossaryBrowser(Client):
 
         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
-            )
-        )
+            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
 
     #
     #   Feedback
     #
-    async def _async_get_comment(
-        self,
-        commemt_guid: str,
-        effective_time: str,
-        for_lineage: bool = False,
-        for_duplicate_processing: bool = False,
-    ) -> dict | list:
+    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)
@@ -3430,26 +3363,17 @@ class GlossaryBrowser(Client):
 
         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}")
 
         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:
+    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)
@@ -3460,33 +3384,21 @@ class GlossaryBrowser(Client):
         for_duplicate_processing_s = str(for_duplicate_processing).lower()
 
         body = {
-            "class": "CommentRequestBody",
-            "commentType": comment_type,
-            "commentText": comment_text,
+            "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}")
 
         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:
+    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)
@@ -3497,37 +3409,23 @@ class GlossaryBrowser(Client):
         for_duplicate_processing_s = str(for_duplicate_processing).lower()
 
         body = {
-            "class": "CommentRequestBody",
-            "commentType": comment_type,
-            "commentText": comment_text,
+            "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}")
 
         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,
-    ):
+    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:
@@ -3545,20 +3443,15 @@ class GlossaryBrowser(Client):
         # validate_search_string(search_string)
 
         body = {
-            "class": "GlossarySearchStringRequestBody",
-            "glossaryGUID": glossary_guid,
-            "searchString": search_string,
-            "effectiveTime": effective_time,
-            "limitResultsByStatus": status_filter,
-        }
+            "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}")
 
@@ -3567,4 +3460,4 @@ class GlossaryBrowser(Client):
 
 
 if __name__ == "__main__":
-    print("Main-Glosssary Browser")
+    print("Main-Glossary Browser")