Index: leahi_dialin/dd/modules/events.py
===================================================================
diff -u -r7d9d004527efeccb91958b440abdff08c2c52648 -rd27c40205e18118f4689f62463a266da1f91dba6
--- leahi_dialin/dd/modules/events.py	(.../events.py)	(revision 7d9d004527efeccb91958b440abdff08c2c52648)
+++ leahi_dialin/dd/modules/events.py	(.../events.py)	(revision d27c40205e18118f4689f62463a266da1f91dba6)
@@ -16,7 +16,7 @@
 
 import struct
 from logging import Logger
-from leahi_dialin.common import *
+from leahi_dialin.common.dd_defs import dd_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
@@ -59,26 +59,26 @@
         self._dd_event_data_type = dict()
 
         # Dictionary of the mode as key and the sub mode states enum class as the value
-        self._dd_op_mode_2_sub_mode = {DDOpModes.MODE_FAUL.name: DDFaultStates,
-                                       DDOpModes.MODE_SERV.name: DDServiceModesStates,
-                                       DDOpModes.MODE_INIT.name: DDInitStates,
-                                       DDOpModes.MODE_STAN.name: DDStandByModeStates,
-                                       DDOpModes.MODE_PREG.name: DDPreGenDialysateStates,
-                                       DDOpModes.MODE_GEND.name: DDGenDialysateModeStates,
-                                       DDOpModes.MODE_POSG.name: DDPostGenDialysateState,
-                                       DDOpModes.MODE_HEAT.name: DDHeatersState,
-                                       DDOpModes.MODE_HCOL.name: DDHeatersCoolingStates,
-                                       DDOpModes.MODE_ROPS.name: DDROPermeateStates,
-                                       DDOpModes.MODE_NLEG.name: DDNotLegalStates}
+        self._dd_op_mode_2_sub_mode = {dd_enum_repository.DDOpModes.MODE_FAUL.name: dd_enum_repository.DDFaultStates,
+                                       dd_enum_repository.DDOpModes.MODE_SERV.name: dd_enum_repository.DDServiceModesStates,
+                                       dd_enum_repository.DDOpModes.MODE_INIT.name: dd_enum_repository.DDInitStates,
+                                       dd_enum_repository.DDOpModes.MODE_STAN.name: dd_enum_repository.DDStandByModeStates,
+                                       dd_enum_repository.DDOpModes.MODE_PREG.name: dd_enum_repository.DDPreGenDialysateStates,
+                                       dd_enum_repository.DDOpModes.MODE_GEND.name: dd_enum_repository.DDGenDialysateModeStates,
+                                       dd_enum_repository.DDOpModes.MODE_POSG.name: dd_enum_repository.DDPostGenDialysateState,
+                                       dd_enum_repository.DDOpModes.MODE_HEAT.name: dd_enum_repository.DDHeatersState,
+                                       dd_enum_repository.DDOpModes.MODE_HCOL.name: dd_enum_repository.DDHeatersCoolingStates,
+                                       dd_enum_repository.DDOpModes.MODE_ROPS.name: dd_enum_repository.DDROPermeateStates,
+                                       dd_enum_repository.DDOpModes.MODE_NLEG.name: dd_enum_repository.DDNotLegalStates}
 
         # Loop through the list of the DD events enums and initial the event dictionary. Each event is a key in the
         # dictionary and the value is a list.
-        for event in DDEventList:
-            self._dd_event_dictionary[DDEventList(event).name] = []
+        for event in dd_enum_repository.DDEventList:
+            self._dd_event_dictionary[dd_enum_repository.DDEventList(event).name] = []
 
         # Loop through the list of the event data type enum and update the dictionary
-        for data_type in DDEventDataType:
-            event_data_type = DDEventDataType(data_type).name
+        for data_type in dd_enum_repository.DDEventDataTypes:
+            event_data_type = dd_enum_repository.DDEventDataTypes(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 +101,14 @@
 
         @returns the requested DD event number
         """
-        list_length = len(self._dd_event_dictionary[DDEventList(event_id).name])
+        list_length = len(self._dd_event_dictionary[dd_enum_repository.DDEventList(event_id).name])
 
         if list_length == 0:
             event = []
         elif event_number > list_length:
-            event = self._dd_event_dictionary[DDEventList(event_id).name][list_length - 1]
+            event = self._dd_event_dictionary[dd_enum_repository.DDEventList(event_id).name][list_length - 1]
         else:
-            event = self._dd_event_dictionary[DDEventList(event_id).name][list_length - event_number - 1]
+            event = self._dd_event_dictionary[dd_enum_repository.DDEventList(event_id).name][list_length - event_number - 1]
 
         return event
 
@@ -133,18 +133,18 @@
         list_of_events = []
 
         # If there are not enough event lists send all the events that are available
-        if len(self._dd_event_dictionary[DDEventList(event_id).name]) <= number_of_events:
-            list_of_events = self._dd_event_dictionary[DDEventList(event_id).name]
+        if len(self._dd_event_dictionary[dd_enum_repository.DDEventList(event_id).name]) <= number_of_events:
+            list_of_events = self._dd_event_dictionary[dd_enum_repository.DDEventList(event_id).name]
         else:
             # Get the all the events
-            complete_list = self._dd_event_dictionary[DDEventList(event_id).name]
+            complete_list = self._dd_event_dictionary[dd_enum_repository.DDEventList(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._dd_event_dictionary[DDEventList(event_id).name]
+            list_of_events = self._dd_event_dictionary[dd_enum_repository.DDEventList(event_id).name]
 
         return list_of_events
 
@@ -166,11 +166,11 @@
         event_id = struct.unpack('i', bytearray(
             message['message'][MsgFieldPositions.START_POS_FIELD_1:MsgFieldPositions.END_POS_FIELD_1]))[0]
 
-        if event_id == DDEventList.DD_EVENT_OPERATION_STATUS.value:
+        if event_id == dd_enum_repository.DDEventList.DD_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._dd_event_data_type[DDEventDataType(event_data_type_1).name]
+            struct_data_type = self._dd_event_data_type[dd_enum_repository.DDEventDataTypes(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(
@@ -179,7 +179,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._dd_event_data_type[DDEventDataType(event_data_type_2).name]
+            struct_data_type = self._dd_event_data_type[dd_enum_repository.DDEventDataTypes(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]
 
@@ -188,53 +188,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._dd_event_data_type[DDEventDataType(event_data_type_1).name]
+            struct_data_type = self._dd_event_data_type[dd_enum_repository.DDEventDataTypes(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._dd_event_data_type[DDEventDataType(event_data_type_2).name]
+            struct_data_type = self._dd_event_data_type[dd_enum_repository.DDEventDataTypes(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 = DDEventList(event_id).name
+        event_state_name = dd_enum_repository.DDEventList(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 == DDEventList.DD_EVENT_OP_MODE_CHANGE.name:
-            event_data_1 = DDOpModes(event_data_1).name
-            event_data_2 = DDOpModes(event_data_2).name
+        if event_state_name == dd_enum_repository.DDEventList.DD_EVENT_OP_MODE_CHANGE.name:
+            event_data_1 = dd_enum_repository.DDOpModes(event_data_1).name
+            event_data_2 = dd_enum_repository.DDOpModes(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 == DDEventList.DD_EVENT_OP_MODE_CHANGE.name:
+        elif event_state_name == dd_enum_repository.DDEventList.DD_EVENT_OP_MODE_CHANGE.name:
             # Get the length of the list of the op mode list
-            op_list_len = len(self._dd_event_dictionary[DDEventList.DD_EVENT_OP_MODE_CHANGE.name])
+            op_list_len = len(self._dd_event_dictionary[dd_enum_repository.DDEventList.DD_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._dd_event_dictionary[DDEventList.DD_EVENT_OP_MODE_CHANGE.name][op_list_len - 1]
+                last_op_tuple = self._dd_event_dictionary[dd_enum_repository.DDEventList.DD_EVENT_OP_MODE_CHANGE.name][op_list_len - 1]
 
             else:
                 # No op mode event has been recieved before the submode event was recieved. 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'),
-                                 DDEventList.DD_EVENT_OP_MODE_CHANGE.name, DDEvents.UNKNOWN_STATE,
-                                 DDOpModes(self.dd_event_op_mode).name)
+                                 dd_enum_repository.DDEventList.DD_EVENT_OP_MODE_CHANGE.name, DDEvents.UNKNOWN_STATE,
+                                 dd_enum_repository.DDOpModes(self.dd_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._dd_event_dictionary[DDEventList.DD_EVENT_SUB_MODE_CHANGE.name])
+            sub_mode_list_len = len(self._dd_event_dictionary[dd_enum_repository.DDEventList.DD_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._dd_event_dictionary[DDEventList.DD_EVENT_SUB_MODE_CHANGE.name][
+                current_sub_tuple = self._dd_event_dictionary[dd_enum_repository.DDEventList.DD_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')
@@ -280,7 +280,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 == DDEventList.DD_EVENT_OPERATION_STATUS.name:
+        elif event_state_name == dd_enum_repository.DDEventList.DD_EVENT_OPERATION_STATUS.name:
             event_tuple = (time(), op_mode, sub_mode, sub_state)
 
         # Update event dictionary