pyegeria 5.4.8.7__py3-none-any.whl → 5.4.8.9__py3-none-any.whl

md_processing/md_commands/feedback_commands.py

@@ -64,7 +64,8 @@ def process_add_comment_command(egeria_client: EgeriaTech, txt: str, directive:
 
     attributes = parsed_output['attributes']
 
-
+    valid = parsed_output['valid']
+    exists = parsed_output['exists']
 
     qualified_name = parsed_output.get('qualified_name', None)
     guid = parsed_output.get('guid', None)
@@ -79,19 +80,18 @@ def process_add_comment_command(egeria_client: EgeriaTech, txt: str, directive:
     associated_element = attributes.get('Associated Element', {}).get('value', None)
     associated_element_guid = attributes.get('Associated Element', {}).get('guid', None)
     description = attributes.get('Comment Text', {}).get('value', None)
-    comment_type = attributes.get('Comment Type', {}).get('value', None)
-    parent_comment = attributes.get('Parent Comment', {}).get('value', None)
-    parent_comment_guid = attributes.get('Parent Comment', {}).get('guid', None)
-
-    if associated_element_guid is None and parent_comment_guid is None:
-        valid = False
-        msg = f"Validation failed for {command} - One of `Associated Element` or `Parent Comment` must be specified\n"
-        logger.error(msg)
-        print(msg)
-    else:
-        if description:
-            valid = True
-            exists = True
+    comment_type = attributes.get('Comment Type', {}).get('value', None).strip()
+
+
+    # if associated_element_guid is None and parent_comment_guid is None:
+    #     valid = False
+    #     msg = f"Validation failed for {command} - One of `Associated Element` or `Parent Comment` must be specified\n"
+    #     logger.error(msg)
+    #     print(msg)
+    # else:
+    #     if description:
+    #         valid = True
+    #         exists = True
     #
 
     if directive == "display":
@@ -109,13 +109,14 @@ def process_add_comment_command(egeria_client: EgeriaTech, txt: str, directive:
             obj = "Comment"
             if comment_type not in COMMENT_TYPES:
                 raise ValueError(f"Invalid comment type: {comment_type}")
-            target_guid = parent_comment_guid if parent_comment_guid else associated_element_guid
+            # target_guid = parent_comment_guid if parent_comment_guid else associated_element_guid
             if qualified_name is None:
-                qualified_name = egeria_client.make_feedback_qn("Comment",target_guid,display_name)
+                qualified_name = egeria_client.make_feedback_qn("Comment",associated_element_guid,display_name)
             #   Set the property body for a glossary collection
             #
             prop_body = {
                     "class": "CommentProperties",
+                    "displayName": display_name,
                     "qualifiedName": qualified_name,
                     "description": description,
                     "commentType": comment_type
@@ -165,20 +166,21 @@ def process_add_comment_command(egeria_client: EgeriaTech, txt: str, directive:
                     return None
 
                 else:
+
                     body = set_create_body(object_type,attributes)
                     body['class'] = "NewAttachmentRequestBody"
                     body["properties"] = prop_body
                     slim_body = body_slimmer(body)
-                    if parent_comment_guid:
-                        guid = egeria_client.add_comment_reply(element_guid = parent_comment_guid, body = slim_body)
-                    else:
-                        guid = egeria_client.add_comment_to_element(element_guid = associated_element_guid, body =slim_body)
+                    # if parent_comment_guid:
+                    #     guid = egeria_client.add_comment_reply(element_guid = parent_comment_guid, body = slim_body)
+                    # else:
+                    guid = egeria_client.add_comment_to_element(element_guid = associated_element_guid, body =slim_body)
 
                     if guid:
                         update_element_dictionary(qualified_name, {
                             'guid': guid, 'display_name': display_name
                             })
-                        msg = f"Created Element `{display_name}` with GUID {guid}\n\n___"
+                        msg = f"## ==> Created Element `{display_name}` with GUID {guid}\n\n___"
                         logger.success(msg)
                         print(Markdown(msg))
                         return egeria_client.get_comment_by_guid(guid, output_format='MD', report_spec = "Comments-DrE")
@@ -196,10 +198,11 @@ def process_add_comment_command(egeria_client: EgeriaTech, txt: str, directive:
     else:
         return None
 
-def process_upsert_note_log_command(egeria_client: EgeriaTech, txt: str, directive: str = "display") -> Optional[str]:
+def process_journal_entry_command(egeria_client: EgeriaTech, txt: str,
+                                         directive: str = "display") -> Optional[str]:
     """
-    Processes a noteLog create or update  object_action by extracting key attributes from the given text and applying
-    this using the pyegeria function.
+    Creates or updates a journal entry. If the journal (NoteLog) doesn't exist, then it will be created. Each journal
+    entry is a note in a NoteLog.
 
     :param txt: A string representing the input cell to be processed for
         extracting glossary-related attributes.
@@ -227,10 +230,24 @@ def process_upsert_note_log_command(egeria_client: EgeriaTech, txt: str, directi
 
     attributes = parsed_output['attributes']
 
-    display_name = attributes['Display Name'].get('value', None)
-    description = attributes['Description'].get('value', None)
+    journal_name = attributes['Journal Name'].get('value', None)
+    journal_qn = attributes['Journal Name'].get('qualified_name', None)
+    journal_exists = attributes['Journal Name'].get('Exists', False)
+    note_entry = attributes['Note Entry'].get('value', None)
+    journal_description = attributes['Journal Description'].get('value', None)
+
     associated_element = attributes.get('Associated Element', {}).get('value', None)
-    associated_element_guid = attributes.get('Associated Element', {}).get('guid', None)
+    associated_element_qn = attributes.get('Associated Element', {}).get('qualified_name', None)
+
+    if journal_exists is False:
+        qualified_name = None
+        journal_qn = None
+
+
+    if journal_name and note_entry:
+        valid = True
+    else:
+        valid = False
     #
 
     if directive == "display":
@@ -244,71 +261,29 @@ def process_upsert_note_log_command(egeria_client: EgeriaTech, txt: str, directi
 
     elif directive == "process":
         try:
-            obj = "NoteLog"
-
-            #   Set the property body for a glossary collection
-            #
-            prop_body = set_element_prop_body(obj, qualified_name, attributes)
 
-            if object_action == "Update":
-                if not exists:
-                    msg = (f" Element `{display_name}` does not exist! Updating result document with Create "
-                           f"{object_action}\n")
-                    logger.error(msg)
-                    return update_a_command(txt, object_action, object_type, qualified_name, guid)
-                elif not valid:
-                    msg = ("  The input data is invalid and cannot be processed. \nPlease review")
+            if object_action == "Create":
+                if valid is False:
+                    msg = "Journal name or Journal entry are missing."
                     logger.error(msg)
+                    print(msg)
                     print(Markdown(f"==> Validation of {command} failed!!\n"))
-                    print(Markdown(msg))
-                    return None
-                else:
-                    print(Markdown(
-                        f"==> Validation of {command} completed successfully! Proceeding to apply the changes.\n"))
-
-
-                body = set_update_body(obj, attributes)
-                body['properties'] = prop_body
-
-                egeria_client.update_note_log(associated_element_guid, body)
-
-                logger.success(f"Updated  {object_type} `{display_name}` with GUID {guid}\n\n___")
-                update_element_dictionary(qualified_name, {
-                    'guid': guid, 'display_name': display_name
-                    })
-                return egeria_client.get_note_logs_by_name(filter = qualified_name, element_type="NoteLog",
-                                                                   output_format='MD', report_spec = "NoteLog-DrE")
-
-
-            elif object_action == "Create":
-                if valid is False and exists:
-                    msg = (f"NoteLog `{display_name}` already exists and result document updated changing "
-                           f"`Create` to `Update` in processed output\n\n___")
-                    logger.error(msg)
-                    return update_a_command(txt, object_action, object_type, qualified_name, guid)
-                elif not valid:
-                    msg = ("The input data is invalid and cannot be processed. \nPlease review")
-                    logger.error(msg)
-                    print(Markdown(f"==> Validation of {command} failed!!\n"))
-                    print(Markdown(msg))
                     return None
 
                 else:
-                    body = set_create_body(object_type,attributes)
 
-                    body["properties"] = prop_body
-                    slim_body = body_slimmer(body)
-                    guid = egeria_client.create_note_log(associated_element_guid, slim_body)
-                    if guid:
-                        update_element_dictionary(qualified_name, {
-                            'guid': guid, 'display_name': display_name
-                            })
-                        msg = f"Created Element `{display_name}` with GUID {guid}\n\n___"
+                    note_guid = egeria_client.add_journal_entry(note_log_qn = journal_qn,
+                                                                   element_qn = associated_element_qn,
+                                                                   note_log_display_name = journal_name,
+                                                                   note_entry = note_entry )
+                    if note_guid:
+                        msg = f"Created entry in `{journal_name}` with GUID {note_guid}\n\n___"
                         logger.success(msg)
-                        return egeria_client.get_note_logs_by_name(filter = qualified_name, element_type="NoteLog",
-                                                                   output_format='MD', report_spec = "NoteLog-DrE")
+                        print(Markdown(msg))
+                        return egeria_client.get_note_by_guid(note_guid,
+                                                                   output_format='MD', report_spec = "Journal-Entry-DrE")
                     else:
-                        msg = f"Failed to create element `{display_name}` with GUID {guid}\n\n___"
+                        msg = f"Failed to create entry for  `{journal_name}`\n\n___"
                         logger.error(msg)
                         return None
 

md_processing/md_processing_utils/common_md_utils.py

@@ -572,8 +572,8 @@ def add_note_in_dr_e(client: Client2, qualified_name: str, display_name: str, jo
         note_log_qn = f"{qualified_name}-NoteLog"
         note_log_display_name = f"{display_name}-NoteLog"
         note_display_name = f"{qualified_name}-Journal-Entry-{datetime.now().strftime('%Y-%m-%d %H:%M')}"
-        journal_entry_guid = client.add_journal_entry(note_log_qn, qualified_name, note_log_display_name, note_display_name,
-                                                             journal_entry)
+        journal_entry_guid = client.add_journal_entry(note_log_qn, qualified_name, note_log_display_name,
+                                                      note_display_name, journal_entry)
         logger.info(f"Added journal entry `{journal_entry_guid}` to `{qualified_name}`")
         return journal_entry_guid
     else:

md_processing/md_processing_utils/extraction_utils.py

@@ -142,17 +142,21 @@ def extract_attribute(text: str, labels: List[str]) -> Optional[str]:
     Returns:
         The cleaned value of the attribute, or None if not found.
     """
+
+
     for label in labels:
-        # Construct pattern for the current label
-        pattern = rf"## {re.escape(label)}\n(.*?)(?=^##|\Z)"  # Captures content until the next '##' or end of text
+        # Construct pattern for the current label - stops at next ##, ___ separator, or end of text
+        pattern = rf"## {re.escape(label)}\n(.*?)(?=^##|^_{3,}|\Z)"
         match = re.search(pattern, text, re.DOTALL | re.MULTILINE)
         if match:
             # Extract matched text
             extracted_text = match.group(1)
 
-            # Remove lines starting with '>'
-            filtered_lines = [line for line in extracted_text.splitlines() if not line.lstrip().startswith(">")]
-
+            # Remove lines starting with '>' and lines that are only underscores/whitespace
+            filtered_lines = [
+                line for line in extracted_text.splitlines()
+                if not line.lstrip().startswith(">") and not re.match(r'^\s*_+\s*$', line)
+            ]
             # Join the lines back, preserving single newlines
             cleaned_text = "\n".join(filtered_lines).strip()
 

md_processing/md_processing_utils/md_processing_constants.py

@@ -6,10 +6,12 @@ import json
 import os
 
 import inflect
+from loguru import logger
 from rich.markdown import Markdown
 
 from md_processing.md_processing_utils.message_constants import ERROR
 from pyegeria._globals import DEBUG_LEVEL
+from pyegeria.logging_configuration import config_logging
 
 inflect_engine = inflect.engine()
 
@@ -167,7 +169,7 @@ COLLECTION_CREATE = ["Create Collection", "Update Collection", "Create Digital P
                 "Update Digital Product Catalog",
                 "Create Root Collection", "Update Root Collection", "Create Folder", "Update Folder",
             ]
-FEEDBACK_COMMANDS = ["Create Comment", "Update Comment", "Create NoteLog", "Update NoteLog", "Create Note", "Update Note",
+FEEDBACK_COMMANDS = ["Create Comment", "Update Comment", "Create Journal Entry",
                      "Create Informal Tag", "Update Informal Tag", "Tag Element"]
 
 command_list = ["Provenance", "Create Glossary", "Update Glossary", "Create Term", "Update Term", "List Terms",
@@ -263,9 +265,10 @@ command_seperator = Markdown("\n---\n")
 EXISTS_REQUIRED = "Exists Required"
 COMMAND_DEFINITIONS = {}
 
+config_logging()
+logger.enable("pyegeria")
 debug_level = DEBUG_LEVEL
 
-
 # def load_commands(filename: str) -> None:
 #     global COMMAND_DEFINITIONS
 #
@@ -288,7 +291,8 @@ def load_commands(filename: str) -> None:
         # Validate JSON before attempting to load
         try:
             COMMAND_DEFINITIONS = json.loads(config_str)
-            print(f"Successfully loaded {filename}")
+            msg = f"Successfully loaded {filename}"
+            logger.info(msg)
         except json.JSONDecodeError as json_err:
             # Provide detailed error information
             error_line = json_err.lineno

pyegeria/_client_new.py

@@ -21,7 +21,7 @@ from pydantic import TypeAdapter
 
 from pyegeria._base_client import BaseClient
 from pyegeria._exceptions_new import (
-    PyegeriaConnectionException, PyegeriaInvalidParameterException, PyegeriaException
+    PyegeriaConnectionException, PyegeriaInvalidParameterException, PyegeriaException, PyegeriaErrorCode
 )
 from pyegeria._globals import max_paging_size, NO_ELEMENTS_FOUND, default_time_out, COMMENT_TYPES
 from pyegeria.base_report_formats import get_report_spec_match
@@ -1317,7 +1317,6 @@ class Client2(BaseClient):
 
     def remove_comment_from_element(
             self,
-            element_guid: str,
             comment_guid: str,
             body: dict | DeleteElementRequestBody = None,
             cascade_delete: bool = False,
@@ -1330,8 +1329,6 @@ class Client2(BaseClient):
 
         Parameters
         ----------
-        element_guid: str
-            - unique id for the element
         comment_guid: str
             - unique id for the comment object
         body: dict | DeleteElementRequestBody, optional
@@ -1349,7 +1346,7 @@ class Client2(BaseClient):
         """
         loop = asyncio.get_event_loop()
         loop.run_until_complete(
-            self._async_remove_note_log(element_guid, body, cascade_delete=cascade_delete)
+            self._async_remove_comment_from_element(comment_guid, body, cascade_delete=cascade_delete)
         )
 
     async def _async_get_comment_by_guid(
@@ -1794,6 +1791,7 @@ class Client2(BaseClient):
                 "class": "NewAttachmentRequestBody",
                 "properties": {
                     "class": "NoteLogProperties",
+                    "typeName": "NoteLog",
                     "displayName": display_name,
                     "qualifiedName": self.make_feedback_qn("NoteLog", element_guid, display_name),
                     "description": description,
@@ -1804,6 +1802,7 @@ class Client2(BaseClient):
                 "class": "NewAElementRequestBody",
                 "properties": {
                     "class": "NoteLogProperties",
+                    "typeName": "NoteLog",
                     "displayName": display_name,
                     "qualifiedName": self.make_feedback_qn("NoteLog", element_guid, display_name),
                     "description": description,
@@ -1817,7 +1816,7 @@ class Client2(BaseClient):
         if element_guid:
             url = f"{self.command_root}feedback-manager/elements/{element_guid}/note-logs"
         else:
-            url = f"{self.command_root}feedback-manager/elements/note-logs"
+            url = f"{self.command_root}feedback-manager/note-logs"
         response = await self._async_make_request("POST", url, body_slimmer(body))
         return response.json()
 
@@ -2296,7 +2295,7 @@ class Client2(BaseClient):
         """
 
         url = f"{self.command_root}feedback-manager/note-logs/by-name"
-        response = await self._async_get_name_request(url, _type=element_type,
+        response = await self._async_get_name_request(url, _type=element_type, filter=filter,
                                                       _gen_output=self._generate_feedback_output, start_from=start_from,
                                                       page_size=page_size, output_format=output_format,
                                                       report_spec=report_spec,
@@ -2438,7 +2437,7 @@ class Client2(BaseClient):
 
     @dynamic_catch
     async def _async_create_note(self, note_log_guid: str, display_name: str = None, description: str = None,
-                                 body: dict | NewElementRequestBody = None) -> str:
+                                 associated_element: str = None, body: dict | NewElementRequestBody = None) -> str:
         """
         Creates a new note for a note log and returns the unique identifier for it. Async version.
 
@@ -2450,6 +2449,8 @@ class Client2(BaseClient):
             - optional display name for the note
         description
             - optional description for the note
+        associated_element: str, default is None
+            - guid of the element to associate with the note - if provided, the note will be anchored to this element.
         body
             - optional body for the note
 
@@ -2501,10 +2502,11 @@ class Client2(BaseClient):
         }
 
         """
+
         if body is None and display_name:
             body = {
                 "class": "NewElementRequestBody",
-                "anchorGUID": note_log_guid,
+                "anchorGUID": associated_element if associated_element else note_log_guid,
                 "isOwnAnchor": False,
                 "parentGUID": note_log_guid,
                 "parentRelationshipTypeName": "AttachedNoteLogEntry",
@@ -2602,8 +2604,10 @@ class Client2(BaseClient):
         return response
 
     @dynamic_catch
-    async def _async_add_journal_entry(self, note_log_qn: str = None, element_qn: str =  None, note_log_display_name: str = None, journal_entry_display_name: str = None, journal_entry_description: str = None,
-                                body: dict | NewElementRequestBody = None ) -> str:
+    async def _async_add_journal_entry(self, note_log_qn: str = None, element_qn: str =  None,
+                                       note_log_display_name: str = None, journal_entry_display_name: str = None,
+                                       note_entry: str = None,
+                                       body: dict | NewElementRequestBody = None) -> str:
         """
         Creates a new journal entry for a note log and returns the unique identifier for it. The note_log will be
         created if it does not exist. Async version.
@@ -2619,7 +2623,7 @@ class Client2(BaseClient):
             - optional note log display name
         journal_entry_display_name: str = None
             - optional journal entry display name
-        journal_entry_description: str = None
+        note_entry: str = None
             - the journal entry text
 
         body
@@ -2683,24 +2687,29 @@ class Client2(BaseClient):
         if note_log_guid is None or note_log_guid == NO_ELEMENTS_FOUND:
             if element_qn is None:
                 if note_log_display_name is None:
-                    note_log_display_name = f"NoName-{datetime.now().strftime('%Y-%m-%d %H:%M')}"
+                    note_log_display_name = f"NoteLog-{datetime.now().strftime('%Y-%m-%d %H:%M')}"
 
             else:
                 element_guid = await self._async_get_guid_for_name(element_qn, ["qualifiedName"])
+                if element_guid is None or element_guid == NO_ELEMENTS_FOUND:
+                    context = { "reason" : "The specified associated element was not found"}
+                    raise PyegeriaException(error_code = PyegeriaErrorCode.VALIDATION_ERROR, context = context)
 
             note_log = await self._async_create_note_log(element_guid = element_guid, display_name = note_log_display_name)
             note_log_guid = note_log["guid"]
 
         # Create the Journal Entry (Note)
+        if journal_entry_display_name is None:
+            journal_entry_display_name = f"Note-{datetime.now().strftime('%Y-%m-%d %H:%M')}"
         journal_entry_guid = await self._async_create_note(note_log_guid, journal_entry_display_name,
-                                                                 journal_entry_description, body)
+                                                           note_entry, body)
 
         return journal_entry_guid
 
     @dynamic_catch
     def add_journal_entry(self, note_log_qn: str = None, element_qn: str = None,
                            note_log_display_name: str = None, journal_entry_display_name: str = None,
-                           journal_entry_description: str = None,
+                          note_entry: str = None,
                            body: dict | NewElementRequestBody = None) -> str:
         """
         Creates a new journal entry for a note log and returns the unique identifier for it. The note_log will be
@@ -2717,7 +2726,7 @@ class Client2(BaseClient):
             - optional note log display name
         journal_entry_display_name: str = None
             - optional journal entry display name
-        journal_entry_description: str = None
+        note_entry: str = None
             - the journal entry text
 
         body
@@ -2773,7 +2782,7 @@ class Client2(BaseClient):
         """
         loop = asyncio.get_event_loop()
         response = loop.run_until_complete(
-            self._async_add_journal_entry(note_log_qn, element_qn, note_log_display_name, journal_entry_display_name, journal_entry_description, body)
+            self._async_add_journal_entry(note_log_qn, element_qn, note_log_display_name, journal_entry_display_name, note_entry, body)
         )
         return response
 
@@ -3563,9 +3572,9 @@ class Client2(BaseClient):
 
         url = f"{self.command_root}feedback-manager/tags/by-name"
 
-        response = await self._async_get_name_request(url, "InformalTag", self._generate_feedback_output,
-                                                      tag_name, [], start_from,
-                                                      page_size, output_format, report_spec)
+        response = await self._async_get_name_request(url, self._generate_feedback_output, tag_name,
+                                                      None,start_from, page_size, output_format, report_spec
+                                                     )
         return response
 
     @dynamic_catch
@@ -4714,6 +4723,11 @@ class Client2(BaseClient):
             extra = self._extract_element_properties_for_keyword(element, columns_struct)
             col_data = overlay_additional_values(col_data, extra)
 
+        note_logs = element.get("presentInNoteLogs", [])
+        if note_logs != []:
+            extra = self._extract_element_properties_for_notes( element, columns_struct)
+            col_data = overlay_additional_values(col_data, extra)
+
         return col_data
 
     @dynamic_catch
@@ -5667,3 +5681,46 @@ class Client2(BaseClient):
             get_additional_props_func=None,
             columns_struct=output_formats,
         )
+
+    def _extract_element_properties_for_keyword(self, element: dict, columns_struct: dict) -> dict:
+        keyword_elements = None
+        keyword_elements = element["keywordElements"]
+        out_body = {}
+        keyword = element["properties"].get('keyword', '')
+        for el in keyword_elements:
+            element = el.get("relatedElement", {})
+            element_guid = element['elementHeader']['guid']
+            element_type = element['elementHeader']['type']['typeName']
+            element_display_name = element['properties'].get('displayName',"")
+            element_description = element['properties'].get('description',"")
+            element_category = element['properties'].get('category',"")
+            out_body = {
+                "element_display_name": element_display_name,
+                "element_description": element_description,
+                "element_category": element_category,
+                "element_type": element_type,
+                "element_guid": element_guid,
+                "keyword": keyword
+            }
+        return out_body
+
+    def _extract_element_properties_for_notes(self, element: dict, columns_struct: dict):
+        note_log_qualified_name = None
+        note_log_guid = None
+        note_log_display_name = None
+        note_log_description = None
+
+        note_log_el = element.get("presentInNoteLogs",{})[0].get("relatedElement",None)
+        if note_log_el:
+            note_log_guid = note_log_el['elementHeader']['guid']
+            note_log_display_name = note_log_el['properties'].get('displayName',"")
+            note_log_qualified_name = note_log_el['properties']['qualifiedName']
+            note_log_description = note_log_el['properties'].get('description',"")
+
+        return {
+            "note_log_name": note_log_display_name,
+            "note_log_description": note_log_description,
+            "note_log_qualified_name": note_log_qualified_name,
+            "note_log_guid": note_log_guid,
+        }
+

pyegeria/_exceptions_new.py

@@ -391,17 +391,25 @@ def print_basic_exception(e: PyegeriaException):
     table.add_column("Item", justify="left", width=80)
 
     if isinstance(e, PyegeriaException):
-        table.add_row("HTTP Code", str(e.response_code))
-        table.add_row("HTTP Reason", str(http_reason))
-        table.add_row("Egeria Code", str(related_code))
-        table.add_row("Caller Method", e.context.get("caller method", "---")) if e.context else ""
-        table.add_row("Request URL", str(e.response_url))
-        table.add_row("Egeria Message",
-                      format_dict_to_string(related_response.get('exceptionErrorMessage',"")) if isinstance(related_response,dict) else related_response)
-        table.add_row("Egeria User Action",
-                      format_dict_to_string(related_response.get('exceptionUserAction',"")) if isinstance(related_response,dict) else related_response)
-
-        exception_msg_id = related_response.get("exceptionErrorMessageId", None) if isinstance(related_response,dict) else related_response
+        if e.context:
+            table.add_row("Context", e.context.get('reason',""), style = "bold yellow")
+        if e.response:
+            table.add_row("HTTP Code", str(e.response_code))
+            table.add_row("HTTP Reason", str(http_reason))
+            table.add_row("Egeria Code", str(related_code))
+            table.add_row("Caller Method", e.context.get("caller method", "---")) if e.context else ""
+            table.add_row("Request URL", str(e.response_url))
+            if related_response:
+                if isinstance(related_response, dict):
+                    table.add_row("Egeria Message",
+                          format_dict_to_string(related_response.get('exceptionErrorMessage',"")))
+                elif isinstance(related_response, str):
+                    table.add_row(related_response,)
+
+            table.add_row("Egeria User Action",
+                          format_dict_to_string(related_response.get('exceptionUserAction',"")) if isinstance(related_response,dict) else related_response)
+
+            exception_msg_id = related_response.get("exceptionErrorMessageId", None) if isinstance(related_response,dict) else related_response
         table.add_row("Pyegeria Exception", exception_msg_id)
         table.add_row("Pyegeria Message", e.message)
         console.print(table)