Index: leahi_dialin/fp/modules/events.py
===================================================================
diff -u -r7d9d004527efeccb91958b440abdff08c2c52648 -re60ad12bcc58d5905d7268bbeaae139d8233e023
--- leahi_dialin/fp/modules/events.py	(.../events.py)	(revision 7d9d004527efeccb91958b440abdff08c2c52648)
+++ leahi_dialin/fp/modules/events.py	(.../events.py)	(revision e60ad12bcc58d5905d7268bbeaae139d8233e023)
@@ -16,7 +16,7 @@
 
 import struct
 from logging import Logger
-from leahi_dialin.common import *
+from leahi_dialin.common.fp_defs import fp_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,24 +59,24 @@
         self._fp_event_data_type = dict()
 
         # Dictionary of the mode as key and the sub mode states enum class as the value
-        self._fp_op_mode_2_sub_mode = {FPOpModes.MODE_FAUL.name: FPFaultStates,
-                                       FPOpModes.MODE_SERV.name: FPServiceStates,
-                                       FPOpModes.MODE_INIT.name: FPPostStates,
-                                       FPOpModes.MODE_STAN.name: FPStandbyStates,
-                                       FPOpModes.MODE_PRE_GENP.name: FPPreGenPermeateStates,
-                                       FPOpModes.MODE_GENP.name: FPGenPermeateStates,
-                                       FPOpModes.MODE_DPGP.name: FPPreGenPDefStates,
-                                       FPOpModes.MODE_DEGP.name: FPGenPermeateDefStates,
-                                       FPOpModes.MODE_NLEG.name: FPNotLegalStates}
+        self._fp_op_mode_2_sub_mode = {fp_enum_repository.FPOpModes.MODE_FAUL.name: fp_enum_repository.FPFaultStates,
+                                       fp_enum_repository.FPOpModes.MODE_SERV.name: fp_enum_repository.FPServiceStates,
+                                       fp_enum_repository.FPOpModes.MODE_INIT.name: fp_enum_repository.FPPostStates,
+                                       fp_enum_repository.FPOpModes.MODE_STAN.name: fp_enum_repository.FPStandbyStates,
+                                       fp_enum_repository.FPOpModes.MODE_PRE_GENP.name: fp_enum_repository.FPPreGenPermeateStates,
+                                       fp_enum_repository.FPOpModes.MODE_GENP.name: fp_enum_repository.FPGenPermeateStates,
+                                       fp_enum_repository.FPOpModes.MODE_DPGP.name: fp_enum_repository.FPPreGenPDefStates,
+                                       fp_enum_repository.FPOpModes.MODE_DEGP.name: fp_enum_repository.FPGenPermeateDefStates,
+                                       fp_enum_repository.FPOpModes.MODE_NLEG.name: fp_enum_repository.FPNotLegalStates}
 
         # Loop through the list of the FP events enums and initial the event dictionary. Each event is a key in the
         # dictionary and the value is a list.
-        for event in FPEventList:
-            self._fp_event_dictionary[FPEventList(event).name] = []
+        for event in fp_enum_repository.FPEventList:
+            self._fp_event_dictionary[fp_enum_repository.FPEventList(event).name] = []
 
         # Loop through the list of the event data type enum and update the dictionary
-        for data_type in FPEventDataType:
-            event_data_type = FPEventDataType(data_type).name
+        for data_type in fp_enum_repository.FPEventDataTypes:
+            event_data_type = fp_enum_repository.FPEventDataTypes(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
@@ -99,14 +99,14 @@
 
         @returns the requested FP event number
         """
-        list_length = len(self._fp_event_dictionary[FPEventList(event_id).name])
+        list_length = len(self._fp_event_dictionary[fp_enum_repository.FPEventList(event_id).name])
 
         if list_length == 0:
             event = []
         elif event_number > list_length:
-            event = self._fp_event_dictionary[FPEventList(event_id).name][list_length - 1]
+            event = self._fp_event_dictionary[fp_enum_repository.FPEventList(event_id).name][list_length - 1]
         else:
-            event = self._fp_event_dictionary[FPEventList(event_id).name][list_length - event_number - 1]
+            event = self._fp_event_dictionary[fp_enum_repository.FPEventList(event_id).name][list_length - event_number - 1]
 
         return event
 
@@ -131,18 +131,18 @@
         list_of_events = []
 
         # If there are not enough event lists send all the events that are available
-        if len(self._fp_event_dictionary[FPEventList(event_id).name]) <= number_of_events:
-            list_of_events = self._fp_event_dictionary[FPEventList(event_id).name]
+        if len(self._fp_event_dictionary[fp_enum_repository.FPEventList(event_id).name]) <= number_of_events:
+            list_of_events = self._fp_event_dictionary[fp_enum_repository.FPEventList(event_id).name]
         else:
             # Get the all the events
-            complete_list = self._fp_event_dictionary[FPEventList(event_id).name]
+            complete_list = self._fp_event_dictionary[fp_enum_repository.FPEventList(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._fp_event_dictionary[FPEventList(event_id).name]
+            list_of_events = self._fp_event_dictionary[fp_enum_repository.FPEventList(event_id).name]
 
         return list_of_events
 
@@ -164,11 +164,11 @@
         event_id = struct.unpack('i', bytearray(
             message['message'][MsgFieldPositions.START_POS_FIELD_1:MsgFieldPositions.END_POS_FIELD_1]))[0]
 
-        if event_id == FPEventList.FP_EVENT_OPERATION_STATUS.value:
+        if event_id == fp_enum_repository.FPEventList.FP_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._fp_event_data_type[FPEventDataType(event_data_type_1).name]
+            struct_data_type = self._fp_event_data_type[fp_enum_repository.FPEventDataType(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(
@@ -177,7 +177,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._fp_event_data_type[FPEventDataType(event_data_type_2).name]
+            struct_data_type = self._fp_event_data_type[fp_enum_repository.FPEventDataType(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]
 
@@ -186,53 +186,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._fp_event_data_type[FPEventDataType(event_data_type_1).name]
+            struct_data_type = self._fp_event_data_type[fp_enum_repository.FPEventDataType(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._fp_event_data_type[FPEventDataType(event_data_type_2).name]
+            struct_data_type = self._fp_event_data_type[fp_enum_repository.FPEventDataType(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 = FPEventList(event_id).name
+        event_state_name = fp_enum_repository.FPEventList(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 == FPEventList.FP_EVENT_OP_MODE_CHANGE.name:
-            event_data_1 = FPOpModes(event_data_1).name
-            event_data_2 = FPOpModes(event_data_2).name
+        if event_state_name == fp_enum_repository.FPEventList.FP_EVENT_OP_MODE_CHANGE.name:
+            event_data_1 = fp_enum_repository.FPOpModes(event_data_1).name
+            event_data_2 = fp_enum_repository.FPOpModes(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 == FPEventList.FP_EVENT_OP_MODE_CHANGE.name:
+        elif event_state_name == fp_enum_repository.FPEventList.FP_EVENT_OP_MODE_CHANGE.name:
             # Get the length of the list of the op mode list
-            op_list_len = len(self._fp_event_dictionary[FPEventList.FP_EVENT_OP_MODE_CHANGE.name])
+            op_list_len = len(self._fp_event_dictionary[fp_enum_repository.FPEventList.FP_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._fp_event_dictionary[FPEventList.FP_EVENT_OP_MODE_CHANGE.name][op_list_len - 1]
+                last_op_tuple = self._fp_event_dictionary[fp_enum_repository.FPEventList.FP_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'),
-                                 FPEventList.FP_EVENT_OP_MODE_CHANGE.name, FPEvents.UNKNOWN_STATE,
-                                 FPOpModes(self.fp_event_op_mode).name)
+                                 fp_enum_repository.FPEventList.FP_EVENT_OP_MODE_CHANGE.name, FPEvents.UNKNOWN_STATE,
+                                 fp_enum_repository.FPOpModes(self.fp_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._fp_event_dictionary[FPEventList.FP_EVENT_SUB_MODE_CHANGE.name])
+            sub_mode_list_len = len(self._fp_event_dictionary[fp_enum_repository.FPEventList.FP_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._fp_event_dictionary[FPEventList.FP_EVENT_SUB_MODE_CHANGE.name][
+                current_sub_tuple = self._fp_event_dictionary[fp_enum_repository.FPEventList.FP_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')
@@ -278,7 +278,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 == FPEventList.FP_EVENT_OPERATION_STATUS.name:
+        elif event_state_name == fp_enum_repository.FPEventList.FP_EVENT_OPERATION_STATUS.name:
             event_tuple = (time(), op_mode, sub_mode, sub_state)
 
         # Update event dictionary