syndesi 0.3.2__py3-none-any.whl → 0.4.1__py3-none-any.whl

syndesi/adapters/backend/adapter_backend.py

@@ -7,27 +7,27 @@
 
 import logging
 import socket
-import uuid
 from abc import ABC, abstractmethod
 from collections.abc import Generator
 from dataclasses import dataclass
 from enum import Enum
 from multiprocessing.connection import Connection
 from threading import Thread
-from time import time
-from typing import Protocol
+import time
+from typing import Protocol, cast
+
+from syndesi.tools.types import NumberLike
 
 from ...tools.backend_api import AdapterBackendStatus, Fragment
 from ...tools.log_settings import LoggerAlias
 from .descriptors import Descriptor
 from .stop_condition_backend import (
-    #LengthBackend,
+    ContinuationBackend,
     StopConditionBackend,
-    #TerminationBackend,
-    #TimeoutStopConditionBackend,
+    TotalBackend,
 )
 
-from ..stop_condition import StopConditionType, TimeoutStopCondition
+from ..stop_condition import Continuation, StopConditionType
 
 
 class HasFileno(Protocol):
@@ -72,13 +72,22 @@ class AdapterDisconnected(AdapterSignal):
         return self.__str__()
 
 
+# @dataclass
+# class AdapterReadInit(AdapterSignal):
+#     end_delay : float | None
+
+#     def __str__(self) -> str:
+#         return f"Read init (end delay : {self.end_delay})"
+
+#     def __repr__(self) -> str:
+#         return self.__str__()
+
 @dataclass
-class AdapterReadInit(AdapterSignal):
-    received_response_in_time: bool
-    uuid: uuid.UUID
+class AdapterResponseTimeout(AdapterSignal):
+    identifier : int
 
     def __str__(self) -> str:
-        return f"Read init [{str(self.uuid)[:5]}...] {'in time' if self.received_response_in_time else 'not in time'}"
+        return f"Response timeout"
 
     def __repr__(self) -> str:
         return self.__str__()
@@ -90,9 +99,9 @@ class AdapterReadPayload(AdapterSignal):
     stop_timestamp: float
     stop_condition_type: StopConditionType
     previous_read_buffer_used: bool
-    response_timestamp : float
+    response_timestamp : float | None
     # Only used by client and set by frontend
-    response_delay : float = 0.0
+    response_delay : float | None = None
 
     def data(self) -> bytes:
         return b"".join([f.data for f in self.fragments])
@@ -109,8 +118,17 @@ class AdapterReadPayload(AdapterSignal):
 @dataclass
 class ResponseRequest:
     timestamp: float
-    uuid: uuid.UUID
+    identifier : int
 
+def nmin(a : float | None, b : float | None) -> float | None:
+    if a is None and b is None:
+        return None
+    elif a is None:
+        return b
+    elif b is None:
+        return a
+    else:
+        return min(a, b)
 
 class AdapterBackend(ABC):
     class ThreadCommands(Enum):
@@ -118,7 +136,7 @@ class AdapterBackend(ABC):
 
     class AdapterTimeoutEventOrigin(Enum):
         TIMEOUT = 0
-        RESPONSE_READ_INIT = 1
+        RESPONSE_REQUEST = 1
 
     def __init__(self, descriptor: Descriptor) -> None:
         """
@@ -136,22 +154,21 @@ class AdapterBackend(ABC):
         super().__init__()
 
         # TODO : Switch to multiple stop conditios
-        self._stop_conditions: list[StopConditionBackend] = [StopConditionBackend(TimeoutStopCondition(
-            continuation=0.1, total=None
-        ))]
+        self._stop_conditions: list[StopConditionBackend] = [
+            ContinuationBackend(time=0.1)
+        ]
         self.descriptor = descriptor
         self._thread: Thread | None = None
         self._status = AdapterBackendStatus.DISCONNECTED
         self._thread_commands_read, self._thread_commands_write = socket.socketpair()
         self.backend_signal: Connection | None = None
         self.fragments: list[Fragment] = []
-        self._start_read_timestamp: float | None = None
-        # self._data_out_queue = []
         self._next_timeout_timestamp: float | None = None
         # _response_time indicates if the frontend asked for a read
         # None : No ask
         # float : Ask for a response to happen at the specified value at max
         self._response_request: ResponseRequest | None = None
+        self._response_request_start : float | None = None
 
         self._first_fragment = True
 
@@ -159,7 +176,7 @@ class AdapterBackend(ABC):
         # not used because of termination or length stop condition
         self._previous_buffer = Fragment(b"", None)
 
-        self._last_write_time = time()
+        self._last_write_time = time.time()
 
     def set_stop_conditions(self, stop_conditions: list[StopConditionBackend]) -> None:
         """
@@ -204,14 +221,6 @@ class AdapterBackend(ABC):
         """
         Stop communication with the device
         """
-        self._logger.debug("Closing adapter and stopping read thread")
-        # self._thread_commands_write.send(self.ThreadCommands.STOP.value)
-        # if self._thread is not None and self._thread.is_alive():
-        #     try:
-        #         self._thread.join()
-        #     except RuntimeError:
-        #         # If the thread cannot be joined, then so be it
-        #         pass
         self._status = AdapterBackendStatus.DISCONNECTED
         return True
 
@@ -223,7 +232,7 @@ class AdapterBackend(ABC):
         ----------
         data : bytes or str
         """
-        self._last_write_time = time()
+        self._last_write_time = time.time()
         self._logger.debug(f"Write {repr(data)}")
         return True
 
@@ -238,9 +247,9 @@ class AdapterBackend(ABC):
     def _socket_read(self) -> Fragment:
         raise NotImplementedError
     
-    def _fragments_to_string(self, fragments : list[bytes]):
+    def _fragments_to_string(self, fragments : list[Fragment]) -> str:
         if len(fragments) > 0:
-            return '+'.join(repr(f) for f in fragments)
+            return '+'.join(repr(f.data) for f in fragments)
         else:
             return str([])
 
@@ -256,28 +265,26 @@ class AdapterBackend(ABC):
         else:
             self._logger.debug(f"New fragment {fragment_delta_t:+.3f} {fragment}" + (" (first)" if self._first_fragment else ""))
             if self._status == AdapterBackendStatus.CONNECTED:
-                t = time()
+                t = time.time()
+
+                # If there's a response request, disable it if there's a timeout stop condition
+                # The stop-condition will do the job
+
+                if self._response_request is not None:
+                    for stop_condition in self._stop_conditions:
+                        if isinstance(stop_condition, (ContinuationBackend, TotalBackend)):
+                            self._response_request = None
+                            break
 
                 while True:
                     if self._first_fragment:
-                        self._read_start_time = t
+                        self._first_fragment = False
+                        self._read_start_timestamp = t
                         for stop_condition in self._stop_conditions:
                             stop_condition.initiate_read()
-                        self._first_fragment = False
-                        if self._response_request is not None:
-                            received_response_in_time = (
-                                t < self._response_request.timestamp
-                            )
-                            # The frontend asked for a response, tell it
-                            yield AdapterReadInit(
-                                received_response_in_time, self._response_request.uuid
-                            )
-                            self._response_request = None
-
 
                     stop = False
                     kept = fragment
-                    self._next_timeout_timestamp
 
                     # Run each stop condition one after the other, if a stop is reached, stop evaluating
                     stop_condition_type : StopConditionType
@@ -285,23 +292,35 @@ class AdapterBackend(ABC):
                         stop, kept, self._previous_buffer, self._next_timeout_timestamp = \
                             stop_condition.evaluate(kept)
                         if stop:
-                            stop_condition_type = stop_condition.stop_condition.type()
+                            stop_condition_type = stop_condition.type()
                             break
 
                     
-                    if kept.data != b'':
-                        self.fragments.append(kept)
+                    # if kept.data != b'':
+                    #     self.fragments.append(kept)
+
+                    self.fragments.append(kept)
 
                     if stop:
                         self._first_fragment = True
                         self._logger.debug(f"Payload {self._fragments_to_string(self.fragments)} ({stop_condition_type.value})")
+                        if self._response_request_start is None or len(self.fragments) == 0:
+                            response_delay = None
+                        else:
+                            if self.fragments[0].timestamp is None:
+                                response_delay = None
+                            else:
+                                response_delay = self.fragments[0].timestamp - self._response_request_start
+                            self._response_request_start = None
                         yield AdapterReadPayload(
                             fragments=self.fragments,
                             stop_timestamp=t,
                             stop_condition_type=stop_condition_type,
                             previous_read_buffer_used=False,
-                            response_timestamp=self.fragments[0].timestamp
+                            response_timestamp=self.fragments[0].timestamp,
+                            response_delay=response_delay
                         )
+                        self._next_timeout_timestamp = None # Experiment !
                         self.fragments.clear()
 
                     if len(self._previous_buffer.data) > 0 and stop:
@@ -315,15 +334,15 @@ class AdapterBackend(ABC):
 
         return None
 
-    def start_read(self, response_time: float, uuid: uuid.UUID) -> None:
+    def start_read(self, response_time: float, identifier: int) -> None:
         """
         Start a read operation. This is a signal from the frontend. The only goal is to set the response time
         and tell the frontend if nothing arrives within a set time
         """
-        t = time()
-        self._start_read_timestamp = t
-        self._logger.debug(f"Setup read [{str(uuid)[:5]}...] in {response_time:.3f} s")
-        self._response_request = ResponseRequest(t + response_time, uuid)
+        self._response_request_start = time.time()
+        self._logger.debug(f"Setup read [{identifier}] in {response_time:.3f} s")
+        self._response_request = ResponseRequest(self._response_request_start + response_time, identifier)
+        
 
     @abstractmethod
     def is_opened(self) -> bool:
@@ -338,31 +357,44 @@ class AdapterBackend(ABC):
         return self.__str__()
 
     def on_timeout_event(self) -> AdapterSignal | None:
-        t = time()
+        t = time.time()
 
         if self._next_timeout_origin == self.AdapterTimeoutEventOrigin.TIMEOUT:
             self._next_timeout_timestamp = None
             self._first_fragment = True
-            self._logger.debug(f"Payload {self._fragments_to_string(self.fragments)} ({StopConditionType.TIMEOUT.value})")
+            if self._response_request_start is None or len(self.fragments) == 0:
+                response_delay = None
+            else:
+                if self.fragments[0].timestamp is not None:
+                    response_delay = self.fragments[0].timestamp - self._response_request_start
+                else:
+                    response_delay = None
+                self._response_request_start = None
+
             output = AdapterReadPayload(
                 stop_timestamp=t,
                 stop_condition_type=StopConditionType.TIMEOUT,
                 previous_read_buffer_used=False,
                 fragments=self.fragments,
-                response_timestamp=self.fragments[0].timestamp
+                response_timestamp=self.fragments[0].timestamp if len(self.fragments) > 0 else None,
+                response_delay=response_delay
             )
+            # Reset response request
+            if self._response_request is not None:
+                self._response_request = None
+                self._response_request_start = None
             # Clear all of the fragments
             self.fragments = []
             return output
 
         elif (
             self._next_timeout_origin
-            == self.AdapterTimeoutEventOrigin.RESPONSE_READ_INIT
+            == self.AdapterTimeoutEventOrigin.RESPONSE_REQUEST
         ):
             if self._response_request is not None:
-                uuid = self._response_request.uuid
+                signal = AdapterResponseTimeout(self._response_request.identifier)
                 self._response_request = None
-                return AdapterReadInit(False, uuid)
+                return signal
 
         return None
 
@@ -370,6 +402,8 @@ class AdapterBackend(ABC):
         min_timestamp = None
         self._next_timeout_origin = None
 
+        t = time.time()
+
         if self._next_timeout_timestamp is not None:
             min_timestamp = self._next_timeout_timestamp
             self._next_timeout_origin = self.AdapterTimeoutEventOrigin.TIMEOUT
@@ -381,7 +415,6 @@ class AdapterBackend(ABC):
             ):
                 min_timestamp = self._response_request.timestamp
                 self._next_timeout_origin = (
-                    self.AdapterTimeoutEventOrigin.RESPONSE_READ_INIT
+                    self.AdapterTimeoutEventOrigin.RESPONSE_REQUEST
                 )
-
         return min_timestamp

syndesi/adapters/backend/adapter_session.py

@@ -13,7 +13,8 @@ from enum import Enum
 from multiprocessing.connection import Pipe, wait
 from typing import Any, Tuple
 
-from syndesi.adapters.backend.stop_condition_backend import StopConditionBackend
+from syndesi.adapters.backend.stop_condition_backend import StopConditionBackend, stop_condition_to_backend
+from syndesi.tools.errors import make_error_description
 from syndesi.tools.types import NumberLike
 
 from ...tools.backend_api import Action, frontend_send
@@ -21,9 +22,10 @@ from ...tools.log_settings import LoggerAlias
 from .adapter_backend import (
     AdapterBackend,
     AdapterDisconnected,
-    AdapterReadInit,
+    #AdapterReadInit,
     AdapterReadPayload,
     Selectable,
+    nmin,
 )
 from .backend_tools import NamedConnection
 from .descriptors import (
@@ -37,52 +39,13 @@ from .ip_backend import IPBackend
 from .serialport_backend import SerialPortBackend
 #from .stop_condition_backend import stop_condition_from_list
 from .visa_backend import VisaBackend
-
+from pathlib import Path
 
 
 class TimeoutEvent(Enum):
     MONITORING = 0
     ADAPTER = 1
-    CONNECTIONS = 2
-
-class TimeoutManager:
-    def __init__(self, monitoring_delay : float) -> None:
-        self._monitoring_delay = monitoring_delay
-        self._timeouts : list[Tuple[TimeoutEvent, float]] = []
-        self._monitoring_timestamp = time.time()
-
-    def get_next_timeout(self) -> Tuple[TimeoutEvent, float]:
-        t = time.time()
-        # Sort the list
-        self._timeouts.sort(key = lambda x : x[1], reverse=True)
-        # Check if the first element of the list is first or if it's the monitoring timeout
-        if len(self._timeouts) > 0 and self._timeouts[0][1] < self._monitoring_timestamp:
-            # A timeout is first
-            event, timestamp = self._timeouts.pop(0)
-            delta = max(0, timestamp - t)
-            return event, delta
-        else:
-            # Monitoring is first
-            self._set_next_monitoring_delay()
-            delta = max(0, self._monitoring_timestamp - t)
-            return TimeoutEvent.MONITORING, delta
-        
-    def _set_next_monitoring_delay(self):
-        t = time.time()
-        self._monitoring_timestamp = t + self._monitoring_delay
-
-    def add_timeout_absolute(self, event : TimeoutEvent, timestamp : float):
-        self._timeouts.append((event, timestamp))
-
-    def add_timeout_relative(self, event : TimeoutEvent, delay : float):
-        self.add_timeout_absolute(event, time.time() + delay)
-
-    def has_event(self, event : TimeoutEvent) -> bool:
-        for _event, _ in self._timeouts:
-            if _event == event:
-                return True
-        return False
-
+    #CONNECTIONS = 2
 
 def get_adapter(descriptor: Descriptor) -> AdapterBackend:
     # The adapter doesn't exist, create it
@@ -109,6 +72,7 @@ class AdapterSession(threading.Thread):
         self._logger = logging.getLogger(LoggerAlias.ADAPTER_BACKEND.value)
         self._logger.setLevel("DEBUG")
         self._role = None
+        self._next_monitoring_timestamp = time.time() + self.MONITORING_DELAY
 
         # self._stop_flag = False
         self._connections_lock = threading.Lock()
@@ -137,7 +101,8 @@ class AdapterSession(threading.Thread):
 
         #self._timeout_events: list[tuple[TimeoutEvent, float]] = []
 
-        self._timeout_manager = TimeoutManager(self.MONITORING_DELAY)
+        self._read_init_id = 0
+
 
 
     def add_connection(self, conn: NamedConnection) -> None:
@@ -151,40 +116,8 @@ class AdapterSession(threading.Thread):
         with self._connections_lock:
             if conn in self.connections:
                 conn.conn.close()
-                # self.connection_names.pop(id(conn), None)
                 self.connections.remove(conn)
 
-    # def _pop_next_timeout_event(self) -> tuple[TimeoutEvent | None, float | None]:
-    #     if len(self._timeout_events) > 0:
-    #         self._timeout_events.sort(key=lambda x: x[1], reverse=True)
-    #         return self._timeout_events.pop(0)
-    #     else:
-    #         return None, None
-
-    # def _has_timeout_event(self, event: TimeoutEvent) -> bool:
-    #     for event, _ in self._timeout_events:
-    #         if event == event:
-    #             return True
-    #     return False
-
-    # def _add_timeout_event(self, event: TimeoutEvent, timestamp: float) -> None:
-    #     self._timeout_events.append((event, timestamp))
-
-        # key_timeouts = [
-        #     (TimeoutEvent.MONITORING, self._timeout_events[TimeoutEvent.MONITORING]),
-        #     (TimeoutEvent.ADAPTER, self._timeout_events[TimeoutEvent.ADAPTER]),
-        # ] + list(self._timeout_events[TimeoutEvent.CONNECTIONS].items())
-
-        # key, timeout = None, None
-        # for k, t in key_timeouts:
-        #     if t is not Ellipsis:
-        #         if isinstance(t, float) or isinstance(t, int):
-        #             if timeout is None or t < timeout:
-        #                 timeout = t
-        #                 key = k
-
-        # return key, timeout
-
     def send(self, conn: NamedConnection, action: Action, *args: Any) -> None:
         if not frontend_send(conn.conn, action, *args):
             self._logger.warning(f"Failed to send to {conn.remote()}")
@@ -201,35 +134,23 @@ class AdapterSession(threading.Thread):
         return self._adapter.is_opened()
 
     def run(self) -> None:
-
         while True:
             try:
                 stop = self.loop()
                 if stop:
                     break
             except Exception as e:
-                tb = e.__traceback__
-                if tb is None:
-                    error_message = ""
-                else:
-                    while tb.tb_next is not None:
-                        tb = tb.tb_next
-                    _type = type(e)
-                    extra_arguments = (str(e),)
-                    line_no = tb.tb_lineno
-                    frame = tb.tb_frame
-                    filename = frame.f_code.co_filename
-                    error_message = (
-                        f"{_type} : {extra_arguments} {filename}:{line_no}"
-                    )
+                error_message = make_error_description(e)
 
 
                 self._logger.critical(
                     f"Error in {self._adapter.descriptor} session loop : {error_message}"
                 )
                 try:
+                    error_message = make_error_description(e)
+                        
                     for conn in self.connections:
-                        frontend_send(conn.conn, Action.ERROR_GENERIC, str(e))
+                        frontend_send(conn.conn, Action.ERROR_GENERIC, error_message)
                 except Exception:
                     break
         self._logger.info(f"Exit {self._adapter.descriptor} session loop")
@@ -253,30 +174,30 @@ class AdapterSession(threading.Thread):
         if adapter_fd is not None and adapter_fd.fileno() >= 0:
             wait_list.append(adapter_fd)
 
-        next_adapter_timeout = self._adapter.get_next_timeout()
-        if (
-            not self._timeout_manager.has_event(TimeoutEvent.ADAPTER)
-            and next_adapter_timeout is not None
-        ):
-            self._timeout_manager.add_timeout_absolute(TimeoutEvent.ADAPTER, next_adapter_timeout)
-
         wait_list.append(self._new_connection_r)
+    
+        timeout_timestamp = None
+        event = None
+
+        adapter_timestamp = self._adapter.get_next_timeout()
+        if adapter_timestamp is not None:
+            timeout_timestamp = nmin(timeout_timestamp, adapter_timestamp)
+            event = TimeoutEvent.ADAPTER
         
-        # event, timeout_timestamp = self._pop_next_timeout_event()
-        # if timeout_timestamp is None:
-        #     timeout = None
-        # else:
-        #     timeout = timeout_timestamp - time.time()
-        
+        if timeout_timestamp is None or self._next_monitoring_timestamp < timeout_timestamp:
+            timeout_timestamp = self._next_monitoring_timestamp
+            event = TimeoutEvent.MONITORING
 
-#asd
-# Probably an infinite wait here that blocks the monitoring
-        event, timeout = self._timeout_manager.get_next_timeout()
+        if timeout_timestamp is None:
+            timeout = None
+        else:
+            timeout = timeout_timestamp - time.time()
         ready = wait(wait_list, timeout=timeout)  # type: ignore
-
+        t = time.time()
         if len(ready) == 0:
             # Timeout event
             if event == TimeoutEvent.MONITORING:
+                self._next_monitoring_timestamp = t + self.MONITORING_DELAY
                 stop = self._monitor()
                 if stop:
                     return True
@@ -285,26 +206,17 @@ class AdapterSession(threading.Thread):
                 if signal is not None:
                     # The signal can be none if it has been disabled in the meantime
                     self._logger.debug(f"Adapter signal (timeout) : {signal}")
-                    if isinstance(signal, AdapterReadPayload):
-                        self.send_to_all(Action.ADAPTER_EVENT_DATA_READY, signal)
-                    elif isinstance(signal, AdapterReadInit):
-                        self.send_to_all(Action.ADAPTER_EVENT_READ_INIT, signal)
+                    self.send_to_all(Action.ADAPTER_SIGNAL, signal)
+
         # Main adapter loop
         if self._new_connection_r in ready:
             # New connection event
-            # os.read(self._new_connection_r, 1)
             self._new_connection_r.recv()
         # Adapter event
         if self._adapter.selectable() in ready:
             for signal in self._adapter.on_socket_ready():
                 self._logger.debug(f"Adapter signal (selectable) : {signal}")
-                if isinstance(signal, AdapterDisconnected):
-                    # TODO : Maybe use Action.EVENT only and the signal specifies which one it is
-                    self.send_to_all(Action.ADAPTER_EVENT_DISCONNECTED, signal)
-                elif isinstance(signal, AdapterReadInit):
-                    self.send_to_all(Action.ADAPTER_EVENT_READ_INIT, signal)
-                elif isinstance(signal, AdapterReadPayload):
-                    self.send_to_all(Action.ADAPTER_EVENT_DATA_READY, signal)
+                self.send_to_all(Action.ADAPTER_SIGNAL, signal)
 
         for conn in self.connections:
             if conn.conn in ready:
@@ -361,18 +273,14 @@ class AdapterSession(threading.Thread):
                     match action:
                         case Action.OPEN:
                             self._adapter.set_stop_conditions(
-                                [StopConditionBackend(sc) for sc in request[1]]
+                                [stop_condition_to_backend(sc) for sc in request[1]]
                             )
                             if self._adapter.open():
                                 # Success !
                                 response_action = Action.OPEN
                             else:
                                 response_action = Action.ERROR_FAILED_TO_OPEN
-                            extra_arguments = ("",)
-                        case Action.FORCE_CLOSE:
-                            self._adapter.close()
-                            remove_after_response = True
-                            response_action, extra_arguments = Action.FORCE_CLOSE, ()
+                            extra_arguments = ("",)                            
                         case Action.WRITE:
                             data = request[1]
                             if self._adapter.is_opened():
@@ -393,48 +301,40 @@ class AdapterSession(threading.Thread):
                                 self._logger.error("Could not write, adapter is closed")
                         case Action.PING:
                             response_action, extra_arguments = Action.PING, ()
-                        case Action.SET_STOP_CONDITION:
-                            stop_conditions = stop_conditions_to_backends(request[1])
-                            self._adapter.set_stop_conditions(stop_conditions)
+                        case Action.SET_STOP_CONDITIONs:
+                            self._adapter.set_stop_conditions([
+                                stop_condition_to_backend(sc) for sc in request[1]
+                                ])
                             response_action, extra_arguments = (
-                                Action.SET_STOP_CONDITION,
+                                Action.SET_STOP_CONDITIONs,
                                 (),
                             )
                         case Action.FLUSHREAD:
                             self._adapter.flush_read()
                             response_action, extra_arguments = Action.FLUSHREAD, ()
-                        # case Action.START_READ:
-                        #     response_time = float(request[1])
-                        #     uuid = request[2]
-                        #     self._adapter.start_read(response_time, uuid)
-                        #     response_action, extra_arguments = Action.START_READ, ()
-                        case Action.GET_BACKEND_TIME:
-                            response_action = Action.GET_BACKEND_TIME
-                            extra_arguments = (request_timestamp, )
+                        case Action.START_READ:
+                            response_time = float(request[1])
+                            self._adapter.start_read(response_time, self._read_init_id)
+                            response_action, extra_arguments = Action.START_READ, (self._read_init_id,)
+                            self._read_init_id += 1
+
+                        # case Action.GET_BACKEND_TIME:
+                        #     response_action = Action.GET_BACKEND_TIME
+                        #     extra_arguments = (request_timestamp, )
                         case Action.CLOSE:
+                            force = request[1]
                             # Close this connection
                             remove_after_response = True
                             response_action, extra_arguments = Action.CLOSE, ()
+                            if force:
+                                self._adapter.close()
                         case _:
                             response_action, extra_arguments = (
                                 Action.ERROR_UNKNOWN_ACTION,
                                 (f"{action}",),
                             )
                 except Exception as e:
-                    tb = e.__traceback__
-                    if tb is None:
-                        error_message = ""
-                    else:
-                        while tb.tb_next is not None:
-                            tb = tb.tb_next
-                        _type = type(e)
-                        extra_arguments = (str(e),)
-                        line_no = tb.tb_lineno
-                        frame = tb.tb_frame
-                        filename = frame.f_code.co_filename
-                        error_message = (
-                            f"{_type} : {extra_arguments} {filename}:{line_no}"
-                        )
+                    error_message = make_error_description(e)
 
                     response_action, extra_arguments = (
                         Action.ERROR_GENERIC,