Index: dialin/utils/nv_ops_utils.py
===================================================================
diff -u -rd3a22e97fad0b715b1e9fba138236334ae7dbb6d -rdb2b8f2dbb5876c6d02a9d2140b52322ae7dce4e
--- dialin/utils/nv_ops_utils.py	(.../nv_ops_utils.py)	(revision d3a22e97fad0b715b1e9fba138236334ae7dbb6d)
+++ dialin/utils/nv_ops_utils.py	(.../nv_ops_utils.py)	(revision db2b8f2dbb5876c6d02a9d2140b52322ae7dce4e)
@@ -20,7 +20,6 @@
 from logging import Logger
 from typing import List
 from collections import OrderedDict
-from .excel_ops import *
 from dialin.utils.base import AbstractObserver, DialinEnum
 
 
@@ -152,249 +151,6 @@
         # of the group.
         self._temp_groups_data_to_calculate_crc = []
 
-    def _create_workspace(self, dir_name):
-        """
-        Publicly accessible function to get create a workspace for the script that is running.
-
-        @param dir_name: Name of the workspace directory
-
-        @return none
-        """
-        # Get the root directory of the current script
-        scripts_root_dir = os.path.dirname(os.path.dirname(__file__))
-        # Get the root directory of the entire scripts folder. The workspace that holds the
-        # code review reports and clones other scripts and repositories must be outside of the scripts
-        root_dir = os.path.dirname(os.path.dirname(scripts_root_dir))
-        # Create the address of the workspace
-        self._workspace_dir = os.path.join(root_dir, dir_name)
-        # If the path does not exist, make it, otherwise, change to that directory
-        if not os.path.isdir(self._workspace_dir):
-            # Create the directory and go to it
-            os.mkdir(self._workspace_dir)
-        os.chdir(self._workspace_dir)
-
-    def prepare_excel_report(self, firmware_stack: str, record_name: str, directory: str, protect_sheet: bool = False):
-        """
-        Publicly accessible function to prepare the excel report
-
-        @param firmware_stack: (str) firmware stack name (e.g. "HD" or "DG")
-        @param record_name: (str) record type to check such as calibration, system, ...
-        @param directory: (str) the directory in which to write the excel document.
-        @param protect_sheet: (bool) flag to indicate whether to write protect the sheet or not (default False)
-        @return none
-        """
-        path = ''
-        is_report_found = False
-
-        # If a directory is provided and there is not a folder in that address, create the
-        # directory. Set the workspace directory to the provided directory. If a directory was not
-        # provided, create a workspace in the default position
-        default_nv_directory = firmware_stack + '_NV_Records'
-
-        if directory is not None:
-            directory = os.path.join(directory, default_nv_directory)
-            if not os.path.isdir(directory):
-                # Create the directory and go to it
-                os.mkdir(directory)
-
-            self._workspace_dir = directory
-            os.chdir(self._workspace_dir)
-        else:
-            self._create_workspace(default_nv_directory)
-
-        self._record_name = record_name
-        self._firmware_stack = firmware_stack
-
-        # List all the files in the workspace directory
-        for file in os.listdir(self._workspace_dir):
-            # If the file has an extension of .xlsx
-            if file.endswith('.xlsx'):
-                # Check if the firmware stack (i.e. DG) is in the file and name of the file
-                # does not have lock in it. When the file is open, there is a hidden lock file
-                # in there and it is ignored
-                file = str(file)
-                if self._firmware_stack in file and 'lock' not in file:
-                    if str(datetime.datetime.now().date()) in file:
-                        if self._SW_CONFIGS_REPORT_NAME in file and self.NON_VOLATILE_RECORD_NAME == record_name:
-                            # Create the file path and exit the loop
-                            path = os.path.join(self._workspace_dir, file)
-                            is_report_found = True
-                            break
-                        elif self._SW_CONFIGS_REPORT_NAME not in file and self.NON_VOLATILE_RECORD_NAME not in \
-                            record_name:
-                            # Create the file path and exit the loop
-                            path = os.path.join(self._workspace_dir, file)
-                            is_report_found = True
-                            break
-
-        if is_report_found:
-            # Load the excel workbook
-            self._excel_workbook = load_excel_report(path)
-        else:
-            # Get an excel workbook object
-            self._excel_workbook = get_an_excel_workbook()
-
-        # Setup worksheet and create the current tab
-        setup_excel_worksheet(self._excel_workbook, self._record_name, protection=protect_sheet)
-
-    def write_fw_record_to_excel(self, calibration_record: OrderedDict):
-        """
-        Writes a calibration record to excel
-        @param calibration_record: (dict) the record to write to excel
-        @return: None
-        """
-        try:
-            row = 1
-            # Let's say the calibration record is:
-            # Get the keys of the calibration group {'pressure_sensors': 'ppi', {'fourth_order': ['<f', 0.0], ... }
-            for group in calibration_record.keys():
-                start_row = row
-                start_col = 1
-                col = 1
-                if isinstance(calibration_record[group], dict):
-                    # Write the data to excel
-                    write_to_excel(self._excel_workbook, self._record_name, row, col, group, bold=True,
-                                   max_col_len=len(group), protect_cell=True)
-                    # Get the list of the hardware and write them to excel (i.e. list of pressure sensors)
-                    for hardware in calibration_record[group].keys():
-                        list_of_keys = list(calibration_record[group].keys())
-                        col = 2
-                        write_to_excel(self._excel_workbook, self._record_name, row, col, hardware, protect_cell=True)
-                        col += 1
-                        # If the list of the sensor hardware is a dictionary, loop through the hardware dictionary
-                        # and write them to excel
-                        if isinstance(calibration_record[group][hardware], dict):
-                            for spec in calibration_record[group][hardware]:
-                                # Get the spec value from the dictionary
-                                spec_value = calibration_record[group][hardware][spec][1]
-                                write_to_excel(self._excel_workbook, self._record_name, row, col, spec,
-                                               protect_cell=True)
-                                col += 1
-                                # If the spec is cal_time and the value is not 0, it means it has been calibrated and
-                                # the time is in epoch. Convert that to date and time.
-                                spec_value = self.get_current_date_time(spec_value) if spec == self._CAL_TIME_NAME and \
-                                    spec_value is not 0 else spec_value
-
-                                # If the spec value that is read is crc, then the value must be protected too. This is
-                                # to make sure the crc is not changed by accident by the user so the calibration fails
-                                # in the firmware
-                                protect = False if spec is not self._CRC_NAME else True
-                                # Write the value to the excel and make the cell protection to false. The actual
-                                # calibration value should be edited
-                                write_to_excel(self._excel_workbook, self._record_name, row, col, spec_value,
-                                               protect_cell=protect)
-                                col += 1
-                        else:
-                            # The hardware value is not a CRC. Write it to excel
-                            spec_value = calibration_record[group][hardware][1]
-                            write_to_excel(self._excel_workbook, self._record_name, row, col, spec_value,
-                                           protect_cell=False)
-
-                        # If all the hardware of a hardware group is written to excel, merge and center the
-                        if list_of_keys.index(hardware) == len(list_of_keys) - 1:
-                            merge_cells(self._excel_workbook, self._record_name, start_row, start_col, row, start_col)
-                        row += 1
-
-                row += 1
-            save_report(self._excel_workbook, self._workspace_dir, self._firmware_stack)
-
-        except Exception as e:
-            self.logger.error("Failed to write calibration record to excel: {0}".format(e))
-
-    def write_excel_record_to_fw_record(self, record: OrderedDict, report_address: str, record_tab: str):
-        """
-        Writes the data in the excel report to the firmware
-
-        @param record: (dict) the record to write to firmware from excel
-        @param report_address: (str) the address of the excel report to get the data from
-        @param record_tab: (str) the name of the excel tab to get the data out (i.e. Calibration Record tab)
-
-        @return: None
-        """
-        try:
-            self._excel_workbook = load_excel_report(report_address)
-            row = 1
-            col = 1
-            # Get the keys of the calibration group {'pressure_sensors': 'ppi', {'fourth_order': ['<f', 0.0], ... }
-            for group in record.keys():
-                # Get the current value of the excel cell
-                cell_value = get_cell_value(self._excel_workbook, record_tab, row, col)
-                # Check if the cell value is a string and if it is, lower case it for comparison
-                cell_value = cell_value.lower() if isinstance(cell_value, str) else cell_value
-                # Check if the current cell value is equal to the group name of the record (i.e. pressure_sensors group
-                # are both in the excel and firmware record. Also, if the group name is padding ignore because it is not
-                # needed to be read from excel
-                if cell_value == group and group is not self._PADDING_GROUP_NAME:
-                    # check if the hardware group is a dictionary
-                    if isinstance(record[group], dict):
-                        # The actual data in the excel starts from column 4
-                        col = 4
-                        for hardware in record[group].keys():
-                            # Loop through the hardware groups and check if it is a dictionary (i.e.
-                            # 'ppi', {'fourth_order': ['<f', 0.0], ... }
-                            if isinstance(record[group][hardware], dict):
-                                for spec in record[group][hardware]:
-                                    cell_value = get_cell_value(self._excel_workbook, record_tab, row, col)
-                                    # Write the cell value that is read into the firmware record.
-                                    record[group][hardware][spec][1] = cell_value
-                                    # Check if the cell value is a string and if it is lower case it for comparison
-                                    cell_value = cell_value.lower() if isinstance(cell_value, str) else cell_value
-                                    # Check if the current spec in the hardware group is cal_time and whether it is
-                                    # None or empty or if it has the word 'new' in the value of the cal_time.
-                                    # When a new calibration value is entered, the cal_time is set to 'new' which is
-                                    # case-insensitive.
-                                    if spec == self._CAL_TIME_NAME and cell_value is None or cell_value is '' or \
-                                        cell_value == self._NEW_CAL_TIME_SIGNAL:
-                                        # So there is a new calibration value. Get the current time in epoch
-                                        # The time in epoch is set to the calibration record to be sent to the firmware
-                                        epoch = self.get_current_time_in_epoch()
-                                        date_time = self.get_current_date_time(epoch)
-                                        record[group][hardware][spec][1] = epoch
-                                        # Once the epoch time is set to the calibration record, calculate the crc of the
-                                        # that hardware group and update the crc to be sent to the firmware
-                                        crc = self.get_group_record_crc(record[group][hardware])
-                                        record[group][hardware][self._CRC_NAME][1] = crc
-                                        # Update the excel report with the newest crc and calibration time
-                                        # Calibration time is converted to date and time.
-                                        # The date and time is the current column number
-                                        write_to_excel(self._excel_workbook, record_tab, row, col, date_time)
-                                        # The crc value is 2 columns after the cal_time value. The crc is protected to
-                                        # make sure it is not changed by the user. These crcs are checked upon POST in
-                                        # the firmware
-                                        write_to_excel(self._excel_workbook, record_tab, row, col + 2, crc,
-                                                       protect_cell=True)
-                                        # Save the excel report
-                                        self._excel_workbook.save(filename=report_address)
-                                    elif spec == self._CAL_TIME_NAME and isinstance(cell_value, str):
-                                        # If the cal_time is in date time and a string, convert that to epoch. This is
-                                        # a date that has been there before so it is only converted to epoch and crc is
-                                        # not calculated
-                                        epoch_time = self.get_date_time_in_epoch(cell_value)
-                                        record[group][hardware][spec][1] = epoch_time
-                                    # Increment the column by two to get the next value
-                                    col += 2
-                                # Increment the row to get the next hardware of the same group
-                                row += 1
-                                # Reset the column to 4 to start reading the next hardware in the same group
-                                col = 4
-                            else:
-                                col = 3
-                                cell_value = get_cell_value(self._excel_workbook, record_tab, row, col)
-                                record[group][hardware][1] = cell_value
-                                if hardware == self._CRC_NAME:
-                                    crc = self.get_group_record_crc(record[group])
-                                    record[group][self._CRC_NAME][1] = crc
-                                row += 1
-
-                        # Go back to the first column to start from the beginning
-                        col = 1
-                        # Once a hardware group is finished, (i.e. the pressure_sensors group) increment the row
-                        # by one. There is an empty row in between each hardware group
-                        row += 1
-
-        except Exception as e:
-            self.logger.error("Failed to load the excel record as a calibration record: {0}".format(e))
-
     @staticmethod
     def get_processed_characters(record: list) -> bytearray:
         """
@@ -465,7 +221,7 @@
         value_in_bytes = b''
         temp = []
         for key, value in group_record.items():
-            if key is not 'crc':
+            if key != 'crc':
                 data_type = value[0]
                 if data_type == '<c':
                     # If the data type is a character, call get processed characters to make sure all the