pyegeria 5.3.8.10__py3-none-any.whl → 5.3.9.1__py3-none-any.whl

pyegeria/__init__.py

@@ -64,7 +64,7 @@ from .md_processing_utils import (extract_command, process_glossary_upsert_comma
                                   process_glossary_list_command, process_category_list_command,
                                   process_term_history_command, process_glossary_structure_command,
                                   process_term_revision_history_command, process_create_term_term_relationship_command,
-                                  )
+                                  process_term_details_command,)
 
 #
 # The following assignments were generated by the `create_tech_guid_lists.py` utility that uses the pyegeria functions

pyegeria/commands/cat/dr_egeria_md.py

@@ -15,7 +15,7 @@ from pyegeria import (extract_command, process_glossary_upsert_command, process_
                       process_solution_component_upsert_command, dr_egeria_state, process_term_list_command,
                       process_category_list_command, process_glossary_list_command, process_term_history_command,
                       process_glossary_structure_command, process_term_revision_history_command,
-                      process_create_term_term_relationship_command)
+                      process_create_term_term_relationship_command, process_term_details_command)
 
 EGERIA_METADATA_STORE = os.environ.get("EGERIA_METADATA_STORE", "active-metadata-store")
 EGERIA_KAFKA_ENDPOINT = os.environ.get("KAFKA_ENDPOINT", "localhost:9092")
@@ -97,6 +97,8 @@ def process_markdown_file(file_path: str, directive: str, server: str, url: str,
                 result = process_create_term_term_relationship_command(client, current_block, directive)
             elif potential_command in ["List Term History", "Term History"]:
                 result = process_term_history_command(client, current_block, directive)
+            elif potential_command in ["List Term Details"]:
+                result = process_term_details_command(client, current_block, directive)
             elif potential_command in ["List Term Update History", "List Term Revision History"]:
                 result = process_term_revision_history_command(client, current_block, directive)
             elif potential_command in ["List Terms", "List Glossary Terms"]:
@@ -150,7 +152,7 @@ def process_markdown_file(file_path: str, directive: str, server: str, url: str,
             in_h1_block = True
 
         # Handle the end of a block (line starts with `---`)
-        elif line.startswith("---"):
+        elif line.startswith("___"):
             if in_h1_block:
                 # Process the current block when it ends with `---`
                 current_block += f"\n{line}"

pyegeria/commands/cat/list_terms.py

@@ -149,7 +149,7 @@ def display_glossary_terms(
             expand=True,
         )
         table.add_column("Term Name / Abbreviation / Version")
-        table.add_column("Qualified Name / GUID", width=38, no_wrap=True)
+        table.add_column("Qualified Name / GUID / Aliases", width=38, no_wrap=True)
         table.add_column("Summary")
         table.add_column("Description")
         table.add_column("Glossary")
@@ -184,8 +184,9 @@ def display_glossary_terms(
             display_name = props.get("displayName","---")
             qualified_name = props["qualifiedName"]
             term_guid = term["elementHeader"]["guid"]
+            aliases = props.get("aliases", "---")
             q_name = Text(
-                f"{qualified_name}\n&\n{term_guid}", style=style, justify="center"
+                f"{qualified_name}\n&\n{term_guid}\n&\n{aliases}", style=style, justify="center"
             )
             abbrev = Text(props.get("abbreviation", "---"), style=style, justify="center")
             summary = Text(props.get("summary", "---"), style=style)

pyegeria/glossary_browser_omvs.py

@@ -12,6 +12,7 @@ from datetime import datetime
 
 from pyegeria import NO_GLOSSARIES_FOUND, max_paging_size
 from pyegeria._client import Client
+from pyegeria._exceptions import InvalidParameterException, PropertyServerException, UserNotAuthorizedException
 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
@@ -222,7 +223,8 @@ class GlossaryBrowser(Client):
             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)
+                                        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, output_format: str = 'LIST') -> str:
@@ -302,14 +304,15 @@ class GlossaryBrowser(Client):
             str: Markdown table
         """
         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': 'Categories', 'key': 'categories_dn_md', 'format': True}, ]
+                   {'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': '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)
+                                              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, output_format: str = 'DICT') -> list:
@@ -368,7 +371,7 @@ class GlossaryBrowser(Client):
             list: List of glossary dictionaries
         """
         return self._generate_entity_dict(elements=elements, extract_properties_func=self._extract_glossary_properties,
-            exclude_keys=['properties', 'categories_qn_md'], output_format=output_format)
+                                          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:
@@ -426,9 +429,9 @@ class GlossaryBrowser(Client):
         aliases = ", ".join(properties.get("aliases", "")) or ""
 
         return {
-            'guid': guid, 'properties': properties, 'display_name': display_name, 'aliases': aliases, 'summary': summary,
-            'description': description, 'examples': examples, 'usage': usage, 'version identifier': pub_version,
-            'qualified_name': qualified_name, 'status': status
+            'guid': guid, 'properties': properties, 'display_name': display_name, 'aliases': aliases,
+            '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]:
@@ -449,7 +452,7 @@ class GlossaryBrowser(Client):
 
         category_list = self.get_categories_for_term(term_guid)
         if type(category_list) is str and category_list == NO_CATEGORIES_FOUND:
-            category_list_md = '---'
+            category_list_md = ''
         elif isinstance(category_list, list) and len(category_list) > 0:
             first_cat = True
             for category in category_list:
@@ -507,16 +510,17 @@ class GlossaryBrowser(Client):
             str: Markdown table
         """
         columns = [{'name': 'Term Name', 'key': 'display_name'}, {'name': 'Qualified Name', 'key': 'qualified_name'},
-            {'name': 'Aliases', 'key': 'aliases', 'format': True}, {'name': 'Summary', 'key': 'summary', 'format': True}, 
-            {'name': 'Glossary', 'key': 'glossary'}, {'name': 'Categories', 'key': 'categories_str', 'format': True}]
+                   {'name': 'Aliases', 'key': 'aliases', 'format': True},
+                   {'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)
+                                              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:
         """
@@ -558,9 +562,10 @@ class GlossaryBrowser(Client):
             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)
-            )
+                                          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:
         """
@@ -597,8 +602,8 @@ class GlossaryBrowser(Client):
             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)
+                                        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:
         """
@@ -776,17 +781,18 @@ class GlossaryBrowser(Client):
             str: Markdown table
         """
         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': 'Description', 'key': 'description', 'format': True},
+                   {'name': 'Qualified Name', 'key': 'qualified_name'},
+                   {'name': 'Parent Category', 'key': 'parent_category'},
+                   {'name': 'Subcategories', 'key': 'subcategories', 'format': True}]
 
         # 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)
 
         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)
+                                              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:
         """
@@ -830,8 +836,9 @@ class GlossaryBrowser(Client):
             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)
+                                          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:
         """
@@ -882,8 +889,9 @@ class GlossaryBrowser(Client):
             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)
+                                        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:
@@ -1079,9 +1087,9 @@ class GlossaryBrowser(Client):
     #
 
     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:
+                                     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.
@@ -1177,9 +1185,9 @@ class GlossaryBrowser(Client):
         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:
+                        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.
@@ -1241,12 +1249,12 @@ 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))
+                                        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:
+                                          output_format: str = "JSON") -> dict | str:
         """Retrieves information about a glossary
         Parameters
         ----------
@@ -1338,7 +1346,7 @@ class GlossaryBrowser(Client):
         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:
+                                            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.
 
@@ -1391,7 +1399,7 @@ class GlossaryBrowser(Client):
         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:
+                               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.
 
@@ -1435,7 +1443,7 @@ class GlossaryBrowser(Client):
     #
 
     async def _async_get_glossary_for_category(self, glossary_category_guid: str,
-            effective_time: str = None, ) -> dict | 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.
 
@@ -1514,8 +1522,9 @@ class GlossaryBrowser(Client):
         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:
+                                                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.
@@ -1571,10 +1580,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:
+                                   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.
@@ -1615,12 +1623,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))
+                                                   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:
+                                              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.
@@ -1704,8 +1713,8 @@ class GlossaryBrowser(Client):
         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:
+                                 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.
@@ -1759,12 +1768,12 @@ 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))
+                                                 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:
+                                                 page_size: int = None, ) -> list | str:
         """Return the list of categories associated with a glossary.
             Async version.
 
@@ -1807,7 +1816,7 @@ class GlossaryBrowser(Client):
         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:
+                                    page_size: int = None, ) -> list | str:
         """Return the list of categories associated with a glossary.
 
         Parameters
@@ -1844,7 +1853,7 @@ class GlossaryBrowser(Client):
         return response
 
     async def _async_get_categories_for_term(self, glossary_term_guid: str, start_from: int = 0,
-            page_size: int = None, ) -> list | str:
+                                             page_size: int = None, ) -> list | str:
         """Return the list of categories associated with a glossary term.
             Async version.
 
@@ -1883,10 +1892,10 @@ class GlossaryBrowser(Client):
                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")
+        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:
+                                page_size: int = None, ) -> list | str:
         """Return the list of categories associated with a glossary term.
 
         Parameters
@@ -1922,7 +1931,7 @@ class GlossaryBrowser(Client):
         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:
+                                            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
@@ -1936,12 +1945,8 @@ class GlossaryBrowser(Client):
             category name to search for.
         glossary_guid: str, optional
             The identity of the glossary to search. If not specified, all glossaries will be searched.
-        status: [str], optional
-            A list of statuses to optionally restrict results. Default is Active
-
-            If not provided, the server name associated with the instance is used.
         start_from: int, [default=0], optional
-                    When multiple pages of results are available, the page number to start from.
+             When multiple pages of results are available, the page number to start from.
         page_size: int, [default=None]
             The number of items to return in a single page. If not specified, the default will be taken from
             the class instance.
@@ -1980,7 +1985,7 @@ class GlossaryBrowser(Client):
         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:
+                               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
@@ -1992,10 +1997,6 @@ class GlossaryBrowser(Client):
             category name to search for.
         glossary_guid: str, optional
             The identity of the glossary to search. If not specified, all glossaries will be searched.
-        status: [str], optional
-            A list of statuses to optionally restrict results. Default is Active
-
-            If not provided, the server name associated with the instance is used.
         start_from: int, [default=0], optional
                     When multiple pages of results are available, the page number to start from.
         page_size: int, [default=None]
@@ -2287,18 +2288,13 @@ class GlossaryBrowser(Client):
                 parent_guid = parent['elementHeader']['guid']
                 parent_name = parent['glossaryCategoryProperties'].get('displayName', '---')
                 parent_info = {
-                    'guid': parent_guid,
-                    'name': parent_name
-                }
+                    'guid': parent_guid, 'name': parent_name
+                    }
 
             return {
-                'guid': category_guid,
-                'name': display_name,
-                'qualifiedName': qualified_name,
-                'description': description,
-                'parent': parent_info,
-                'children': children
-            }
+                '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:
@@ -2309,9 +2305,8 @@ class GlossaryBrowser(Client):
         # Format the output according to the specified output_format
         if output_format == "DICT":
             return {
-                'glossary_guid': glossary_guid,
-                'categories': category_tree
-            }
+                'glossary_guid': glossary_guid, 'categories': category_tree
+                }
         elif output_format == "LIST":
             # Generate markdown table
             md_table = "| Category | Path | Description | Parent Category | Child Categories |\n"
@@ -2333,7 +2328,9 @@ class GlossaryBrowser(Client):
                         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"
+                    md_table += (f"| {category['name']} | {category_path} | "
+                                 f"{self._format_for_markdown_table(category['description'])} | "
+                                 f"{parent_name} | {child_categories} |\n")
                     if category['children']:
                         add_categories_to_table(category['children'], category_path)
 
@@ -2365,14 +2362,12 @@ class GlossaryBrowser(Client):
         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:
+                                            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.
 
@@ -2423,7 +2418,7 @@ 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:
+                               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.
 
@@ -2464,7 +2459,7 @@ class GlossaryBrowser(Client):
         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:
+                                            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
@@ -2513,7 +2508,7 @@ 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:
+                               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
@@ -2551,7 +2546,7 @@ class GlossaryBrowser(Client):
         return response
 
     async def _async_get_related_terms(self, term_guid: str, effective_time: str = None, start_from: int = 0,
-                                       page_size: int = None, output_format:str = "JSON") -> list | str:
+                                       page_size: int = None, output_format: str = "JSON") -> 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
@@ -2606,12 +2601,11 @@ class GlossaryBrowser(Client):
             elif output_format == 'DICT':
                 return None
         if output_format != "JSON":  # return a simplified markdown representation
-            return self.generate_terms_md(term_elements, term_guid, output_format)
+            return self.generate_related_terms_md(term_elements, term_guid, output_format)
         return response.json().get("elementList", NO_TERMS_FOUND)
 
-
-    def get_related_terms(self, term_guid: str, effective_time: str = None, start_from: int = 0,
-                          page_size: int = None, output_format = "JSON") -> list | str:
+    def get_related_terms(self, term_guid: str, effective_time: str = None, start_from: int = 0, page_size: int = None,
+                          output_format="JSON") -> 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
@@ -2644,36 +2638,205 @@ class GlossaryBrowser(Client):
         """
         loop = asyncio.get_event_loop()
         response = loop.run_until_complete(
-            self._async_get_related_terms(term_guid, effective_time, start_from,
-                                          page_size, output_format))
+            self._async_get_related_terms(term_guid, effective_time, start_from, page_size, output_format))
 
         return response
 
-    def get_term_details(self, term_name:str, effective_time: str = None) -> dict | str:
-        """Retrieve the details of a glossary term. Including relationships and feedback
+    def generate_related_terms_md(self, term_elements: list, term_guid: str, output_format: str = 'MD') -> str | list:
+        """
+        Generate a simplified representation of related terms.
 
-        output_format: str, default = 'JSON'
+        Args:
+            term_elements (list): List of term elements with relationship information
+            term_guid (str): GUID of the term for which to generate related terms
+            output_format (str): Output format (MD, LIST, DICT, etc.)
+
+        Returns:
+            str | list: Markdown string or list of dictionaries depending on output_format
+        """
+        # Get the first term's display name and qualified name
+        term_name = "Term"
+        try:
+            term_info = self.get_term_by_guid(term_guid, output_format="DICT")
+            # Handle case where term_info is a list of dictionaries
+            if isinstance(term_info, list) and len(term_info) > 0:
+                term_info = term_info[0]  # Get the first term
+            if isinstance(term_info, dict) and 'display_name' in term_info:
+                term_name = term_info['display_name']
+        except:
+            # If we can't get the term info, just use the default name
+            pass
+
+        # Create a list to store the simplified related terms
+        related_terms = []
+
+        # Process each term element
+        for element in term_elements:
+            # Extract relationship type from the relationship header
+            relationship_type = element['relatedElement']['relationshipHeader']['type']['typeName']
+
+            # Extract related term information
+            related_term = {
+                'first_term_display_name': term_name, 'first_term_qualified_name': term_info.get('qualified_name', ''),
+                'related_term_display_name': element['glossaryTermProperties'].get('displayName', ''),
+                'related_term_qualified_name': element['glossaryTermProperties'].get('qualifiedName', ''),
+                'relationship_type': relationship_type
+                }
+
+            related_terms.append(related_term)
+
+        # Return based on output format
+        if output_format == 'DICT':
+            return related_terms
+
+        # For MD, LIST, FORM, REPORT formats, create a markdown representation
+        md_output = f"# Related Terms for {term_name}\n\n"
+
+        if output_format == 'LIST':
+            # Create a table
+            md_output += ("| First Term | First Term Qualified Name | Related Term | Related Term Qualified Name | "
+                          "Relationship Type |\n")
+            md_output += \
+                "|------------|---------------------------|--------------|------------------------------|-------------------|\n"
+
+            for term in related_terms:
+                md_output += f"| {term['first_term_display_name']} | {term['first_term_qualified_name']} | "
+                md_output += f"{term['related_term_display_name']} | {term['related_term_qualified_name']} | "
+                md_output += f"{term['relationship_type']} |\n"
+        else:
+            # For other formats, create a more detailed representation
+            for term in related_terms:
+                md_output += f"## {term['relationship_type']} Relationship\n\n"
+                md_output += (f"**First Term:** {term['first_term_display_name']} ("
+                              f"{term['first_term_qualified_name']})\n\n")
+                md_output += f"**Related Term:** {term[('related_term_dis'
+                                                        'play_name')]} ({term['related_term_qualified_name']})\n\n"
+                md_output += "---\n\n"
+
+        return md_output
+
+    def get_term_details(self, term_name: str, effective_time: str = None, output_format: str = 'DICT') -> dict | str:
+        """Retrieve detailed information about a term, combining basic term details and related terms.
+
+        This method combines the term details retrieved from get_term_by_guid and the related terms
+        information from generate_related_terms_md.
+
+        Parameters
+        ----------
+        term_name : str
+            Either the display name or the qualified name of the term to retrieve.
+        effective_time : str, optional
+            Time at which the term is active. If not specified, the current time is used.
+        output_format : str, default = 'DICT'
             Type of output to produce:
-            JSON - output standard json
-            MD - output standard markdown with no preamble
-            DICT = output a simplified DICT structure
+                DICT - output a dictionary with combined term details and related terms
+                REPORT - output a markdown report with combined term details and related terms
+
+        Returns
+        -------
+        dict | str
+            A dictionary or markdown string containing the combined term details and related terms.
+
+        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.
         """
+        # Check if the output format is supported
+        if output_format not in ["DICT", "REPORT"]:
+            return f"Unsupported output format: {output_format}. Supported formats are DICT and REPORT."
 
+        # Search for the term using the qualified name
+        terms = self.get_terms_by_name(term_name, effective_time=effective_time, output_format="DICT")
 
-        # Now lets get the term details as a dict
-        core = self.get_terms_by_name(term_name, effective_time, output_format="DICT")
-        if not core:
-            return NO_TERMS_FOUND
+        # Check if we found any terms
+        if not terms or (isinstance(terms, str) and terms == NO_TERMS_FOUND):
+            return f"No term found with name: {term_name}"
 
-        related = self.get_related_terms(core[0]['guid'], effective_time)
-        if not related:
-            return "NO RELATED TERMS FOUND"
+        # Make sure we only have one term
+        if isinstance(terms, list) and len(terms) > 1:
+            return f"Multiple terms found with name: {term_name} - please specify the qualified name."
 
-        related_term_guid = related[0]["relatedElement"]["relatedElement"]["guid"]
-        related_term_qn = related[0]["relatedElement"]["relatedElement"]["uniquedName"]
+        term_details = terms[0]
 
+        # Get related terms
+        try:
+            related_terms_response = self.get_related_terms(term_details.get('guid', ''), output_format="DICT")
+        except (InvalidParameterException, PropertyServerException, UserNotAuthorizedException):
+            # If we can't get related terms, set to empty list
+            related_terms_response = []
 
+        # If no related terms were found, set to empty list
+        if isinstance(related_terms_response, str) and related_terms_response == NO_TERMS_FOUND:
+            related_terms = []
+        elif related_terms_response is None:
+            related_terms = []
+        else:
+            related_terms = related_terms_response
 
+        # Combine the data
+        if output_format == "DICT":
+            # Create a combined dictionary
+            combined_data = {
+                "term_details": term_details, "related_terms": related_terms
+                }
+            return combined_data
+        elif output_format == "REPORT":
+            # Create a markdown report
+            md_output = f"# Term Details Report for `{term_name}` \n\n"
+
+            # Add term details
+            md_output += "## Basic Term Information\n\n"
+            md_output += f"**Display Name:** {term_details.get('display_name', '')}\n\n"
+            md_output += f"**Qualified Name:** {term_details.get('qualified_name', '')}\n\n"
+            md_output += f"**GUID:** {term_details.get('guid', '')}\n\n"
+
+            if 'summary' in term_details and term_details['summary']:
+                md_output += f"**Summary:** {term_details.get('summary', '')}\n\n"
+
+            if 'description' in term_details and term_details['description']:
+                md_output += f"**Description:** {term_details.get('description', '')}\n\n"
+
+            if 'examples' in term_details and term_details['examples']:
+                md_output += f"**Examples:** {term_details.get('examples', '')}\n\n"
+
+            if 'usage' in term_details and term_details['usage']:
+                md_output += f"**Usage:** {term_details.get('usage', '')}\n\n"
+
+            if 'aliases' in term_details and term_details['aliases']:
+                md_output += f"**Aliases:** {term_details.get('aliases', '')}\n\n"
+
+            if 'status' in term_details and term_details['status']:
+                md_output += f"**Status:** {term_details.get('status', '')}\n\n"
+
+            if 'in_glossary' in term_details and term_details['in_glossary']:
+                md_output += f"**Glossary:** {term_details.get('in_glossary', '')}\n\n"
+
+            if 'categories' in term_details and term_details['categories']:
+                md_output += f"**Categories:** {', '.join(term_details.get('categories', []))}\n\n"
+
+            # Add related terms
+            md_output += "## Related Terms\n\n"
+
+            if not related_terms:
+                md_output += "No related terms found.\n\n"
+            else:
+                # Create a table for related terms
+                md_output += "| Related Term | Qualified Name | Relationship Type |\n"
+                md_output += "|--------------|---------------|-------------------|\n"
+
+                for term in related_terms:
+                    md_output += f"| {term.get('related_term_display_name', '')} | "
+                    md_output += f"{term.get('related_term_qualified_name', '')} | "
+                    md_output += f"{term.get('relationship_type', '')} |\n"
+
+            return md_output
+        else:
+            return f"Unsupported output format: {output_format}. Supported formats are DICT and REPORT."
 
     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
@@ -2752,8 +2915,9 @@ class GlossaryBrowser(Client):
         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, output_format = "JSON") -> list:
+                                       effective_time: str = None, for_lineage: bool = False,
+                                       for_duplicate_processing: bool = False, start_from: int = 0,
+                                       page_size: int = None, output_format="JSON") -> list:
         """Retrieve glossary terms by display name or qualified name. Async Version.
 
         Parameters
@@ -2831,10 +2995,9 @@ class GlossaryBrowser(Client):
             return self.generate_terms_md(term_elements, term, output_format)
         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, output_format = "JSON") -> list:
+                          effective_time: str = None, for_lineage: bool = False, for_duplicate_processing: bool = False,
+                          start_from: int = 0, page_size: int = None, output_format="JSON") -> list:
         """Retrieve glossary terms by display name or qualified name.
 
         Parameters
@@ -2883,7 +3046,7 @@ 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, output_format))
+                                          for_duplicate_processing, start_from, page_size, output_format))
         return response
 
     async def _async_get_term_by_guid(self, term_guid: str, output_format: str = 'JSON') -> dict | str:
@@ -2960,10 +3123,11 @@ class GlossaryBrowser(Client):
         return response
 
     async def _async_get_term_versions(self, term_guid: str, effective_time: str = None, from_time: str = None,
-            to_time: str = None, oldest_first: bool = False, for_lineage: bool = False,
-            for_duplicate_processing: bool = False, start_from: int = 0, page_size=max_paging_size,
+                                       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:
+                                       ) -> list | str:
         """Retrieve the versions of a glossary term. Async version.
         Parameters
         ----------
@@ -3017,8 +3181,8 @@ class GlossaryBrowser(Client):
         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:
+                          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
         ----------
@@ -3123,7 +3287,7 @@ class GlossaryBrowser(Client):
         return response
 
     async def _async_get_term_revision_history(self, term_revision_log_guid: str, start_from: int = 0,
-            page_size=None, ) -> dict | str:
+                                               page_size=None, ) -> dict | str:
         """Retrieve the revision history for a glossary term. Async version.
 
         Parameters
@@ -3168,7 +3332,7 @@ class GlossaryBrowser(Client):
         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:
+                                  page_size=None, ) -> dict | str:
         """Retrieve the revision history for a glossary term.
 
         Parameters
@@ -3230,7 +3394,6 @@ class GlossaryBrowser(Client):
             If output_format is "LIST", returns a markdown table of the revision history.
             If no revision logs are found, returns a string message "No revision logs found".
         """
-        import re
         validate_guid(term_guid)
 
         # Get revision logs for the term
@@ -3258,15 +3421,15 @@ class GlossaryBrowser(Client):
                 update_time = title[keyword_index + 2:].strip()
 
                 entry_data = {
-                    'qualifiedName': qualified_name,
-                    'title': title,
-                    'text': entry.get('properties', {}).get('text', '---'),
-                    'updateTime': update_time  # Use extracted date/time or fall back to title
-                }
+                    'qualifiedName': qualified_name, 'title': title,
+                    'text': entry.get('properties', {}).get('text', '---'), 'updateTime': update_time
+                    # Use extracted date/time or fall back to title
+                    }
                 all_entries.append(entry_data)
 
         # Sort entries by update time
-        sorted_entries = sorted(all_entries, key=lambda x: x['updateTime'] if x['updateTime'] != '---' else '', reverse=True)
+        sorted_entries = sorted(all_entries, key=lambda x: x['updateTime'] if x['updateTime'] != '---' else '',
+                                reverse=True)
 
         # Return in the specified format
         if output_format == "DICT":
@@ -3310,7 +3473,6 @@ class GlossaryBrowser(Client):
             # Default to DICT format
             return sorted_entries
 
-
     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.
@@ -3385,9 +3547,10 @@ class GlossaryBrowser(Client):
             return None
 
     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:
+                                         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
@@ -3486,9 +3649,10 @@ class GlossaryBrowser(Client):
         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:
+                            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
@@ -3553,7 +3717,8 @@ 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))
+                                            ends_with, ignore_case, for_lineage, for_duplicate_processing, start_from,
+                                            page_size, output_format))
 
         return response
 
@@ -3561,7 +3726,7 @@ class GlossaryBrowser(Client):
     #   Feedback
     #
     async def _async_get_comment(self, commemt_guid: str, effective_time: str, for_lineage: bool = False,
-            for_duplicate_processing: bool = False, ) -> dict | list:
+                                 for_duplicate_processing: bool = False, ) -> dict | list:
         """Retrieve the comment specified by the comment GUID"""
 
         validate_guid(commemt_guid)
@@ -3584,7 +3749,7 @@ class GlossaryBrowser(Client):
         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:
+                                       for_lineage: bool = False, for_duplicate_processing: bool = False, ) -> str:
         """Reply to a comment"""
 
         validate_guid(comment_guid)
@@ -3609,7 +3774,8 @@ class GlossaryBrowser(Client):
         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:
+                                    is_merge_update: bool = False, for_lineage: bool = False,
+                                    for_duplicate_processing: bool = False, ) -> str:
         """Update the specified comment"""
 
         validate_guid(comment_guid)
@@ -3634,9 +3800,9 @@ class GlossaryBrowser(Client):
         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, ):
+                                  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:

pyegeria/md_processing_utils.py

@@ -25,7 +25,7 @@ from pyegeria.project_manager_omvs import ProjectManager
 EGERIA_WIDTH = int(os.environ.get("EGERIA_WIDTH", "170"))
 console = Console(width=EGERIA_WIDTH)
 
-command_list = ["Provenance", "Create Glossary", "Update Glossary", "Create Term", "Update Term", "List Terms",
+command_list = ["Provenance", "Create Glossary", "Update Glossary", "Create Term", "Update Term", "List Terms", "List Term Details",
                 "List Glossary Terms", "List Term History", "List Term Revision History", "List Term Update History",
                 "List Glossary Structure", "List Glossaries", "List Categories", "List Glossary Categories",
                 "Create Personal Project", "Update Personal Project", "Create Category", "Update Category",
@@ -360,8 +360,7 @@ def update_a_command(txt: str, command: str, obj_type: str, q_name: str, u_guid:
     verb = command.split(' ')[0].strip()
     action = "Update" if (verb == "Create" and u_guid is not None) else "Create"
     txt = txt.replace(f"{command}", f'{action} {obj_type}\n')  # update the command
-    txt = txt.replace('<GUID>', f'GUID\n{u_guid}')  # update with GUID
-    txt = txt.replace('<Qualified Name>', f"Qualified Name\n{q_name}")
+
     if "Qualified Name" not in txt:
         txt += f"\n## Qualified Name\n{q_name}\n"
     if "GUID" not in txt:
@@ -978,11 +977,13 @@ def process_glossary_upsert_command(egeria_client: EgeriaTech, txt: str, directi
         if valid:
             print(Markdown(glossary_display))
         else:
-            msg = f"Validation failed for Glossary `{glossary_name}`\n"
-            print_msg(ERROR, msg, debug_level)
-            print(Markdown(glossary_display))
-            return None
-
+            if glossary_exists and object_action == "Create":
+                msg = f"Create failed because glossary `{glossary_name}` exists - changing `Create` to `Update` in processed output \n"
+                print_msg(ERROR, msg, debug_level)
+                print(Markdown(glossary_display))
+                return update_a_command(txt, command, object_type, known_q_name, known_guid)
+            else:
+                return None
         if object_action == "Update":
             if not glossary_exists:
                 print(f"\n{ERROR}Glossary `{glossary_name}` does not exist! Updating result document with Create "
@@ -1123,10 +1124,13 @@ def process_category_upsert_command(egeria_client: EgeriaTech, txt: str, directi
         if valid:
             print(Markdown(category_display))
         else:
-            msg = f"* --> Validation failed for {object_type} `{category_name}`\n"
-            print_msg(ERROR, msg, debug_level)
-            print(Markdown(category_display))
-            return None
+            if category_exists and object_action == "Create":
+                msg = f"Create failed because category `{category_name}` exists - changing `Create` to `Update` in processed output \n"
+                print_msg(ERROR, msg, debug_level)
+                print(Markdown(category_display))
+                return update_a_command(txt, command, object_type, known_q_name, known_guid)
+            else:
+                return None
 
         if object_action == "Update":
             if not category_exists:
@@ -1173,7 +1177,7 @@ def process_category_upsert_command(egeria_client: EgeriaTech, txt: str, directi
                     'guid': category_guid, 'display_name': category_name
                     })
                 print_msg(ALWAYS, f"Created Category `{category_name}` with GUID {category_guid}", debug_level)
-                if parent_valid & parent_exists:
+                if parent_valid and parent_guid:
                     egeria_client.set_parent_category(parent_guid, category_guid)
                     print_msg(ALWAYS, f"Set parent category for `{category_name}` to `{parent_category_name}`",
                               debug_level)
@@ -1297,7 +1301,7 @@ def process_term_upsert_command(egeria_client: EgeriaTech, txt: str, directive:
     version = process_simple_attribute(txt, ['Version', "Version Identifier", "Published Version"], INFO)
     q_name = process_simple_attribute(txt, ['Qualified Name'], INFO)
 
-    aliases = process_simple_attribute(txt, ['Aliases'], INFO)
+    aliases = process_simple_attribute(txt, ['Aliases','Alias'], INFO)
     if aliases:
         alias_list = list(filter(None, re.split(r'[,\s]+', aliases.strip())))
     else:
@@ -1382,7 +1386,14 @@ def process_term_upsert_command(egeria_client: EgeriaTech, txt: str, directive:
     elif directive == "process":
         try:
             if not valid:  # First validate the term before we process it
-                return None
+                if term_exists and object_action == "Create":
+                    msg = f"Create failed because term `{term_name}` exists - changing `Create` to `Update` in processed output \n"
+                    print_msg(ERROR, msg, debug_level)
+                    print(Markdown(term_display))
+                    return update_a_command(txt, command, object_type, known_q_name, known_guid)
+                else:
+                    return None
+
             print(Markdown(term_display))
             if object_action == "Update" and directive == "process":
                 if not term_exists:
@@ -1471,16 +1482,16 @@ def process_create_term_term_relationship_command(egeria_client: EgeriaTech, txt
     term2_guid = None
 
 
-    term_relationship = process_simple_attribute(txt, ["Term Relationship"], "ERROR")
+    term_relationship = process_simple_attribute(txt, ["Term Relationship", "Relationship Type"], "ERROR")
     if term_relationship not in TERM_RELATIONSHPS:
         valid = False
 
     print(Markdown(f"{pre_command} `{command}` for term relationship: `{term_relationship}` with directive: `{directive}` "))
 
-    term1_q_name, term1_guid, term1_valid, term1_exists = process_element_identifiers(egeria_client, object_type, ["Term 1 Name"], txt,
+    term1_q_name, term1_guid, term1_valid, term1_exists = process_element_identifiers(egeria_client, object_type, ["Term 1 Name", "Term 1"], txt,
                                                                      "Exists Required", None )
 
-    term2_q_name, term2_guid, term2_valid, term2_exists = process_element_identifiers(egeria_client, object_type, ["Term 2 Name"], txt,
+    term2_q_name, term2_guid, term2_valid, term2_exists = process_element_identifiers(egeria_client, object_type, ["Term 2 Name", "Term 2"], txt,
                                                                      "Exists Required", None )
 
     request_display = (f"\n\t* Term 1 Qualified Name: {term1_q_name}\n\t* Term 2 Qualified Name {term2_q_name}\n\t"
@@ -1515,7 +1526,6 @@ def process_create_term_term_relationship_command(egeria_client: EgeriaTech, txt
         return None
 
 
-
 def process_per_proj_upsert_command(egeria_client: ProjectManager, txt: str, directive: str = "display") -> str | None:
     """
     Processes a personal project create or update command by extracting key attributes such as
@@ -1678,7 +1688,7 @@ def process_term_list_command(egeria_client: EgeriaTech, txt: str, directive: st
         search_string = '*'
     print(Markdown(f"{pre_command} `{command}` with search string:`{search_string}` with directive: `{directive}`"))
 
-    glossary = process_simple_attribute(txt, ['Glossary', 'In Glossary'])
+    glossary = process_simple_attribute(txt, ['Glossary', 'In Glossary', "Glossary Name"])
     if glossary is not None:
         _, glossary_guid, _, glossary_exists = get_element_by_name(egeria_client, "Glossary", glossary)
         msg = f"Found glossary `{glossary}` with GUID {glossary_guid}"
@@ -1892,6 +1902,58 @@ def process_glossary_list_command(egeria_client: EgeriaTech, txt: str, directive
         return None
 
 
+def process_term_details_command(egeria_client: EgeriaTech, txt: str, directive: str = "display") -> Optional[str]:
+    """ List terms as a markdown table. Filter based on optional search string. """
+    set_debug_level(directive)
+    valid = True
+    command = extract_command(txt)
+    object_type = command.split(' ')[1].strip()
+    object_action = command.split(' ')[0].strip()
+
+
+    term_identifier = process_simple_attribute(txt, TERM_NAME_LABELS, "ERROR")
+
+    print(Markdown(f"{pre_command} `{command}` for term:`{term_identifier}` with directive: `{directive}`"))
+
+    output_format = process_simple_attribute(txt, OUTPUT_LABELS, "INFO")
+    if output_format is None:
+        output_format = "REPORT"
+    else:
+        output_format = output_format.upper()
+
+    if output_format not in ["DICT", "REPORT"]:
+        valid = False
+        print_msg(ERROR, f"Invalid output format: `{output_format}`", debug_level)
+
+    request_display = f"\n\t* Term Identifier: {term_identifier}\n\t* Output Format {output_format}"
+
+    if directive == "display":
+        print(request_display)
+        return None
+    elif directive == "validate":
+        print(request_display)
+        return valid
+    elif directive == "process":
+        try:
+            print(request_display)
+            if not valid:  # First validate the term before we process it
+                return None
+            output = egeria_client.get_term_details(term_identifier, output_format=output_format)
+            if output_format == "DICT":
+                output = f"```{json.dumps(output, indent=4)}```"
+            print_msg("ALWAYS", f"Wrote Term Details for term: `{term_identifier}`", debug_level)
+
+            return output
+
+        except Exception as e:
+            print(f"{ERROR}Error performing {command}: {e}")
+            console.print_exception(show_locals=True)
+            return None
+    else:
+        return None
+
+
+
 def process_term_history_command(egeria_client: EgeriaTech, txt: str, directive: str = "display") -> Optional[str]:
     """ List terms as a markdown table. Filter based on optional search string. """
     set_debug_level(directive)

{pyegeria-5.3.8.10.dist-info → pyegeria-5.3.9.1.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.3
 Name: pyegeria
-Version: 5.3.8.10
+Version: 5.3.9.1
 Summary: A python client for Egeria
 License: Apache 2.0
 Keywords: egeria,metadata,governance

{pyegeria-5.3.8.10.dist-info → pyegeria-5.3.9.1.dist-info}/RECORD

@@ -1,5 +1,5 @@
 pyegeria/README.md,sha256=PwX5OC7-YSZUCIsoyHh1O-WBM2hE84sm3Bd4O353NOk,1464
-pyegeria/__init__.py,sha256=kqNIJb2ZvIoBXDZwfoCj92C2J6gSVyfgvt0WQnKN_EE,30764
+pyegeria/__init__.py,sha256=Oqge4nZQv6-9TRx8UaC2cj8YKkaIJzjo0ySRfbqlwFI,30793
 pyegeria/_client.py,sha256=lCWq8XJOFg3MnEO4ulMVuCJrW3uU4eWUCcbLEd90_LU,34673
 pyegeria/_deprecated_gov_engine.py,sha256=dWNcwVsE5__dF2u4QiIyQrssozzzOjBbLld8MdpmVCQ,17264
 pyegeria/_exceptions.py,sha256=1SrnV194V4_YJNnNAU0myTHQ3dhLn4GF2B2gZcj1u90,18153
@@ -16,7 +16,7 @@ pyegeria/commands/cat/README.md,sha256=-aaAnIT2fcfU63vajgB-RzQk4l4yFdhkyVfSaTPiq
 pyegeria/commands/cat/__init__.py,sha256=5OCy4m_yZsnSxdy_gvkCyP_OkjvuWKimqUGHYCJc_qA,450
 pyegeria/commands/cat/dr_egeria_inbox/glossary_creation_experiment.ipynb,sha256=dbzNu90fCKNohOWVSRBOB1GLyd95x8Qw51I5AkaPtso,11552
 pyegeria/commands/cat/dr_egeria_jupyter.py,sha256=h9LmDmejmaPDlDuGNlVor-bqNnKPvSBhcC7JFWBdOEM,5710
-pyegeria/commands/cat/dr_egeria_md.py,sha256=OCY1tu6NMi0-rTCTOuiRw6wHGZYNY9iS-XmCYRMoC0s,11610
+pyegeria/commands/cat/dr_egeria_md.py,sha256=6Pamoku_psDqrfK5TdAfJIcFU2stUmsnpR-lEkLEsr0,11789
 pyegeria/commands/cat/exp_list_glossaries.py,sha256=dC6Bnfm3YSMTKPP146qeslIFRiZnGu5b7iDYE07p4iU,5817
 pyegeria/commands/cat/get_asset_graph.py,sha256=xnXJfpDTVH1TJ2TwE3dtjaXU36Di6-N6JAyhothzz2o,12461
 pyegeria/commands/cat/get_collection.py,sha256=kXPcP8u-SMWfrVyyBhNoxG8mcgB7EV_5i9N9w_IBU7o,5379
@@ -36,7 +36,7 @@ pyegeria/commands/cat/list_glossaries.py,sha256=D2ovkffSmnO-NQ7y-Jw0aDBtK2j06CQz
 pyegeria/commands/cat/list_projects.py,sha256=NzWTuepTGUEyxK-eWvuUxtBgCtNWubVwmz2eqm2UN1c,7997
 pyegeria/commands/cat/list_tech_type_elements.py,sha256=-9omj5en9dSP1xMSljYVHyfXsuhuE1bO2IFj_bZPhAs,6873
 pyegeria/commands/cat/list_tech_types.py,sha256=uqZcXHCzAznhEG6WWeM5j-spwUh8ycygFqpVDeXOG-0,4653
-pyegeria/commands/cat/list_terms.py,sha256=HPZ_S_5EwJezdgf8UY1dZiDbN5P9aD88pI_rBHftm1M,12185
+pyegeria/commands/cat/list_terms.py,sha256=GoGfvJ7W5KoFDc0b15F7RMr2EM2vo4rKHgpGmELjQL0,12259
 pyegeria/commands/cat/list_todos.py,sha256=NitCw0uyVVjmN1hxb1W-I4FbOsa8wQxW2ICyOElHyc8,6556
 pyegeria/commands/cat/list_user_ids.py,sha256=X5Q-YNEp38saPYDuy9VwdQC5Qpa4HyC3WvAdbyp_P6M,5108
 pyegeria/commands/cli/__init__.py,sha256=hpTVSMP2gnPRhcAZPdeUEsQ-eaDySlXlk239dNWYmng,292
@@ -226,11 +226,11 @@ pyegeria/egeria_my_client.py,sha256=eOKLk2zdI6FHZnhAimfR_0yNdBjpUgD41dJZcJODcqE,
 pyegeria/egeria_tech_client.py,sha256=uycgYfCpb4jzFfaQ7I5JxbZ5PKsWdaWxLOJjbw6C2Zk,3817
 pyegeria/feedback_manager_omvs.py,sha256=0xBs0p54vmdfVYYgQ8pOanLC4fxfgTk1Z61Y6D1U7_I,152978
 pyegeria/full_omag_server_config.py,sha256=CQqLCy_3DZFvJZEOcGf50HWdFaWpiAIs6z-kKyjvpDA,47464
-pyegeria/glossary_browser_omvs.py,sha256=oxOch569LtyQA35sROtXjS_XAVD4Ek-2ApiqFoKRZRQ,161667
+pyegeria/glossary_browser_omvs.py,sha256=QXjr1tLmxXz81wW4MpiY3PhzBY4tHdIgV2KC5pD0ikc,172375
 pyegeria/glossary_manager_omvs.py,sha256=aGYZFuzWrPmPLLNwkNpV7-FsalqwDR7gyBzgdubnM04,87989
 pyegeria/m_test.py,sha256=M5-M2ZczsAJLXWfSeqTTADHdx6Ku-y4PbQ4M21JthAE,7778
 pyegeria/md_processing_helpers.py,sha256=sV-ciVg_xOGVGTH_CMpH2B5k3V5jzdFp_XvnQQ5xafw,2131
-pyegeria/md_processing_utils.py,sha256=wLt-lOxyVuMJr_JN90qJsbt9xD7eCexu_icGuPZqL5E,94233
+pyegeria/md_processing_utils.py,sha256=AbCw8Hr4hIiwRX5pxY9IJGTNlogbdF0tyovt3mmNpxo,96992
 pyegeria/md_processing_utils_orig.py,sha256=64eVP86__zI4EdzwveskDyLiw6EyWJXZW4pqk9aLpuM,52486
 pyegeria/mermaid_utilities.py,sha256=sQqdFUWdNpHu9d3Tk9UVe80M-5bOzses0XcFYX5FF-E,54254
 pyegeria/metadata_explorer_omvs.py,sha256=xHnZTQKbd6XwOhYia-RiIisrvZcqHi0SL1l6OCf04Gk,86911
@@ -245,8 +245,8 @@ pyegeria/template_manager_omvs.py,sha256=chBljs1vy5wr9DRAtbvIt4Cob_7HxGfxLkCNlDT
 pyegeria/utils.py,sha256=GCt1C0bp0Xng1ahzbZhzV9qQwH7Dj93IaCt2dvWb-sg,5417
 pyegeria/valid_metadata_omvs.py,sha256=Xq9DqBQvBFFJzaFIRKcVZ2k4gJvSh9yeXs_j-O3vn1w,65050
 pyegeria/x_action_author_omvs.py,sha256=RcqSzahUKCtvb_3u_wyintAlc9WFkC_2v0E12TZs8lQ,6433
-pyegeria-5.3.8.10.dist-info/LICENSE,sha256=xx0jnfkXJvxRnG63LTGOxlggYnIysveWIZ6H3PNdCrQ,11357
-pyegeria-5.3.8.10.dist-info/METADATA,sha256=_RPRxspNSRd8BtM8mymkGp6VvPRDVAWRMTnvSMjIUks,2758
-pyegeria-5.3.8.10.dist-info/WHEEL,sha256=XbeZDeTWKc1w7CSIyre5aMDU_-PohRwTQceYnisIYYY,88
-pyegeria-5.3.8.10.dist-info/entry_points.txt,sha256=eAvQ_vkejlF3JzMzEc5VD93ymLA_hSFV0HM8fntG-d8,6791
-pyegeria-5.3.8.10.dist-info/RECORD,,
+pyegeria-5.3.9.1.dist-info/LICENSE,sha256=xx0jnfkXJvxRnG63LTGOxlggYnIysveWIZ6H3PNdCrQ,11357
+pyegeria-5.3.9.1.dist-info/METADATA,sha256=TDFkuc1HYbzt76TyjjdKAIyNf_gv9Bmr1z5v61h0HMk,2757
+pyegeria-5.3.9.1.dist-info/WHEEL,sha256=XbeZDeTWKc1w7CSIyre5aMDU_-PohRwTQceYnisIYYY,88
+pyegeria-5.3.9.1.dist-info/entry_points.txt,sha256=eAvQ_vkejlF3JzMzEc5VD93ymLA_hSFV0HM8fntG-d8,6791
+pyegeria-5.3.9.1.dist-info/RECORD,,