Index: leahi_dialin/td/modules/events.py
===================================================================
diff -u -r18c90a1b2b6c7339bdd192a2d2fac32f2b8a35df -rc5bfcf84ed942ca5841bf9de155aa0f495b4d28d
--- leahi_dialin/td/modules/events.py	(.../events.py)	(revision 18c90a1b2b6c7339bdd192a2d2fac32f2b8a35df)
+++ leahi_dialin/td/modules/events.py	(.../events.py)	(revision c5bfcf84ed942ca5841bf9de155aa0f495b4d28d)
@@ -19,9 +19,7 @@
 from datetime import datetime
 from time import time
 
-from leahi_dialin.common.td_defs import TDEventList, TDEventDataType, TDOpModes, TDFaultStates, \
-    TDServiceStates, TDInitStates, TDStandbyStates, TDTreatmentParamStates, TDPreTreatmentModesStates, \
-    TDTreatmentStates, TDPostTreatmentStates, TDNotLegalStates
+from leahi_dialin.common.td_defs import td_enum_repository
 from leahi_dialin.common.msg_defs import MsgIds, MsgFieldPositions
 from leahi_dialin.protocols.CAN import DenaliChannels
 from leahi_dialin.utils.base import AbstractSubSystem, publish
@@ -60,24 +58,24 @@
         self._td_event_data_type = dict()
 
         # Dictionary of the mode as key and the sub mode states enum class as the value
-        self._td_op_mode_2_sub_mode = {TDOpModes.MODE_FAUL.name: TDFaultStates,
-                                       TDOpModes.MODE_SERV.name: TDServiceStates,
-                                       TDOpModes.MODE_INIT.name: TDInitStates,
-                                       TDOpModes.MODE_STAN.name: TDStandbyStates,
-                                       TDOpModes.MODE_TPAR.name: TDTreatmentParamStates,
-                                       TDOpModes.MODE_PRET.name: TDPreTreatmentModesStates,
-                                       TDOpModes.MODE_TREA.name: TDTreatmentStates,
-                                       TDOpModes.MODE_POST.name: TDPostTreatmentStates,
-                                       TDOpModes.MODE_NLEG.name: TDNotLegalStates}
+        self._td_op_mode_2_sub_mode = {td_enum_repository.TDOpModes.MODE_FAUL.name: td_enum_repository.TDFaultStates,
+                                       td_enum_repository.TDOpModes.MODE_SERV.name: td_enum_repository.TDServiceStates,
+                                       td_enum_repository.TDOpModes.MODE_INIT.name: td_enum_repository.TDInitStates,
+                                       td_enum_repository.TDOpModes.MODE_STAN.name: td_enum_repository.TDStandbyStates,
+                                       td_enum_repository.TDOpModes.MODE_TPAR.name: td_enum_repository.TDTreatmentParamStates,
+                                       td_enum_repository.TDOpModes.MODE_PRET.name: td_enum_repository.TDPreTreatmentModesStates,
+                                       td_enum_repository.TDOpModes.MODE_TREA.name: td_enum_repository.TDTreatmentStates,
+                                       td_enum_repository.TDOpModes.MODE_POST.name: td_enum_repository.TDPostTreatmentStates,
+                                       td_enum_repository.TDOpModes.MODE_NLEG.name: td_enum_repository.TDNotLegalStates}
 
         # Loop through the list of the TD events enums and initial the event dictionary. Each event is a key in the
         # dictionary and the value is a list.
-        for event in TDEventList:
-            self._td_event_dictionary[TDEventList(event).name] = []
+        for event in td_enum_repository.TDEventList:
+            self._td_event_dictionary[td_enum_repository.TDEventList(event).name] = []
 
         # Loop through the list of the event data type enum and update the dictionary
-        for data_type in TDEventDataType:
-            event_data_type = TDEventDataType(data_type).name
+        for data_type in td_enum_repository.TDEventDataTypes:
+            event_data_type = td_enum_repository.TDEventDataTypes(data_type).name
             struct_unpack_type = None
 
             # If U32 is in the data type enum (i.e. EVENT_DATA_TYPE_U32), then the key is the enum and the value is
@@ -101,14 +99,14 @@
 
         @returns the requested TD event number
         """
-        list_length = len(self._td_event_dictionary[TDEventList(event_id).name])
+        list_length = len(self._td_event_dictionary[td_enum_repository.TDEventList(event_id).name])
 
         if list_length == 0:
             event = []
         elif event_number > list_length:
-            event = self._td_event_dictionary[TDEventList(event_id).name][list_length - 1]
+            event = self._td_event_dictionary[td_enum_repository.TDEventList(event_id).name][list_length - 1]
         else:
-            event = self._td_event_dictionary[TDEventList(event_id).name][list_length - event_number - 1]
+            event = self._td_event_dictionary[td_enum_repository.TDEventList(event_id).name][list_length - event_number - 1]
 
         return event
 
@@ -135,18 +133,18 @@
         list_of_events = []
 
         # If there are not enough event lists send all the events that are available
-        if len(self._td_event_dictionary[TDEventList(event_id).name]) <= number_of_events:
-            list_of_events = self._td_event_dictionary[TDEventList(event_id).name]
+        if len(self._td_event_dictionary[td_enum_repository.TDEventList(event_id).name]) <= number_of_events:
+            list_of_events = self._td_event_dictionary[td_enum_repository.TDEventList(event_id).name]
         else:
             # Get the all the events
-            complete_list = self._td_event_dictionary[TDEventList(event_id).name]
+            complete_list = self._td_event_dictionary[td_enum_repository.TDEventList(event_id).name]
             # Since the last <number_of_message> are located at the end of the list, iterate backwards for the defined
             # event messages
             for i in range(len(complete_list) - 1, len(complete_list) - number_of_events - 1, -1):
                 list_of_events.append(complete_list[i])
 
         if number_of_events == 0:
-            list_of_events = self._td_event_dictionary[TDEventList(event_id).name]
+            list_of_events = self._td_event_dictionary[td_enum_repository.TDEventList(event_id).name]
 
         return list_of_events
 
@@ -169,11 +167,11 @@
         event_id = struct.unpack('i', bytearray(
             message['message'][MsgFieldPositions.START_POS_FIELD_1:MsgFieldPositions.END_POS_FIELD_1]))[0]
 
-        if event_id == TDEventList.TD_EVENT_OPERATION_STATUS.value:
+        if event_id == td_enum_repository.TDEventList.TD_EVENT_OPERATION_STATUS.value:
             # Get the data type
             event_data_type_1 = struct.unpack('i', bytearray(
                 message['message'][MsgFieldPositions.START_POS_FIELD_2:MsgFieldPositions.END_POS_FIELD_2]))[0]
-            struct_data_type = self._td_event_data_type[TDEventDataType(event_data_type_1).name]
+            struct_data_type = self._td_event_data_type[td_enum_repository.TDEventDataTypes(event_data_type_1).name]
             op_mode = struct.unpack('<B', bytearray(
                 message['message'][MsgFieldPositions.START_POS_FIELD_3:MsgFieldPositions.START_POS_FIELD_3+1]))[0]
             sub_mode = struct.unpack('<B', bytearray(
@@ -182,7 +180,7 @@
                 message['message'][MsgFieldPositions.START_POS_FIELD_3+2:MsgFieldPositions.START_POS_FIELD_3+3]))[0]
             event_data_type_2 = struct.unpack('i', bytearray(
                 message['message'][MsgFieldPositions.START_POS_FIELD_4:MsgFieldPositions.END_POS_FIELD_4]))[0]
-            struct_data_type = self._td_event_data_type[TDEventDataType(event_data_type_2).name]
+            struct_data_type = self._td_event_data_type[td_enum_repository.TDEventDataTypes(event_data_type_2).name]
             event_data_2 = struct.unpack(struct_data_type, bytearray(
                 message['message'][MsgFieldPositions.START_POS_FIELD_5:MsgFieldPositions.END_POS_FIELD_5]))[0]
 
@@ -191,53 +189,53 @@
             event_data_type_1 = struct.unpack('i', bytearray(
                 message['message'][MsgFieldPositions.START_POS_FIELD_2:MsgFieldPositions.END_POS_FIELD_2]))[0]
             # Get the corresponding structure format
-            struct_data_type = self._td_event_data_type[TDEventDataType(event_data_type_1).name]
+            struct_data_type = self._td_event_data_type[td_enum_repository.TDEventDataTypes(event_data_type_1).name]
             # Get the data value by unpacking the data type
             event_data_1 = struct.unpack(struct_data_type, bytearray(
                 message['message'][MsgFieldPositions.START_POS_FIELD_3:MsgFieldPositions.END_POS_FIELD_3]))[0]
 
             event_data_type_2 = struct.unpack('i', bytearray(
                 message['message'][MsgFieldPositions.START_POS_FIELD_4:MsgFieldPositions.END_POS_FIELD_4]))[0]
 
-            struct_data_type = self._td_event_data_type[TDEventDataType(event_data_type_2).name]
+            struct_data_type = self._td_event_data_type[td_enum_repository.TDEventDataTypes(event_data_type_2).name]
             event_data_2 = struct.unpack(struct_data_type, bytearray(
                 message['message'][MsgFieldPositions.START_POS_FIELD_5:MsgFieldPositions.END_POS_FIELD_5]))[0]
 
         # Convert the event ID to enum
-        event_state_name = TDEventList(event_id).name
+        event_state_name = td_enum_repository.TDEventList(event_id).name
         # Get the current timestamp and create a tuple of the current events
         event_tuple = (datetime.now().astimezone().strftime('%Y-%m-%d %H:%M:%S.%f'), event_state_name, event_data_1, event_data_2)
         # Check if the event state name is operation mode change. If it is, get the name of the operation modes
         # from the op modes enum class
-        if event_state_name == TDEventList.TD_EVENT_OP_MODE_CHANGE.name:
-            event_data_1 = TDOpModes(event_data_1).name
-            event_data_2 = TDOpModes(event_data_2).name
+        if event_state_name == td_enum_repository.TDEventList.TD_EVENT_OP_MODE_CHANGE.name:
+            event_data_1 = td_enum_repository.TDOpModes(event_data_1).name
+            event_data_2 = td_enum_repository.TDOpModes(event_data_2).name
             event_tuple = (datetime.now().astimezone().strftime('%Y-%m-%d %H:%M:%S.%f'), event_state_name, event_data_1, event_data_2)
         # Check if the event state name is sub mode change.
-        elif event_state_name == TDEventList.TD_EVENT_OP_MODE_CHANGE.name:
+        elif event_state_name == td_enum_repository.TDEventList.TD_EVENT_OP_MODE_CHANGE.name:
             # Get the length of the list of the op mode list
-            op_list_len = len(self._td_event_dictionary[TDEventList.TD_EVENT_OP_MODE_CHANGE.name])
+            op_list_len = len(self._td_event_dictionary[td_enum_repository.TDEventList.TD_EVENT_OP_MODE_CHANGE.name])
             # Get the last tuple of the op mode
             # It is a list of tuples that each tuple is (timestamp, event type, prev op mode, current op mode)
             if op_list_len != 0:
-                last_op_tuple = self._td_event_dictionary[TDEventList.TD_EVENT_OP_MODE_CHANGE.name][op_list_len - 1]
+                last_op_tuple = self._td_event_dictionary[td_enum_repository.TDEventList.TD_EVENT_OP_MODE_CHANGE.name][op_list_len - 1]
 
             else:
                 # No op mode event has been received before the submode event was received. Use broadcast messages to
                 # determine current op mode. Previous mode can not be known
                 last_op_tuple = (datetime.now().astimezone().strftime('%Y-%m-%d %H:%M:%S.%f'),
-                                 TDEventList.TD_EVENT_OP_MODE_CHANGE.name, TDEvents.UNKNOWN_STATE,
-                                 TDOpModes(self.td_event_op_mode).name)
+                                 td_enum_repository.TDEventList.TD_EVENT_OP_MODE_CHANGE.name, TDEvents.UNKNOWN_STATE,
+                                 td_enum_repository.TDOpModes(self.td_event_op_mode).name)
             # Get the current and previous operation modes of the last tuple in the list of the sub modes
             # i.e. (timestamp, event type, prev, current)
             current_op_mode = last_op_tuple[len(last_op_tuple) - 1]
             current_op_mode_timestamp = datetime.strptime(last_op_tuple[0], '%Y-%m-%d %H:%M:%S.%f')
 
-            sub_mode_list_len = len(self._td_event_dictionary[TDEventList.TD_EVENT_SUB_MODE_CHANGE.name])
+            sub_mode_list_len = len(self._td_event_dictionary[td_enum_repository.TDEventList.TD_EVENT_SUB_MODE_CHANGE.name])
 
             if sub_mode_list_len != 0:
                 # Get the tuple prior to the last tuple and get its previous and current operation modes
-                current_sub_tuple = self._td_event_dictionary[TDEventList.TD_EVENT_SUB_MODE_CHANGE.name][
+                current_sub_tuple = self._td_event_dictionary[td_enum_repository.TDEventList.TD_EVENT_SUB_MODE_CHANGE.name][
                     sub_mode_list_len - 1]
 
                 current_sub_mode_timestamp = datetime.strptime(current_sub_tuple[0], '%Y-%m-%d %H:%M:%S.%f')
@@ -283,7 +281,7 @@
                     event_data_2 = current_sub_mode_enum_class(event_data_2).name
             event_tuple = (datetime.now().astimezone().strftime('%Y-%m-%d %H:%M:%S.%f'), event_state_name, event_data_1, event_data_2)
 
-        elif event_state_name == TDEventList.TD_EVENT_OPERATION_STATUS.name:
+        elif event_state_name == td_enum_repository.TDEventList.TD_EVENT_OPERATION_STATUS.name:
             event_tuple = (time(), op_mode, sub_mode, sub_state)
 
         # Update event dictionary