add ReductionTableHandler unit testing

RefRed/calculations/update_reduction_table_metadata.py

@@ -1,6 +1,5 @@
-from qtpy import QtWidgets, QtCore
-
 from RefRed.interfaces.mytablewidget import ReductionTableColumnIndex
+from RefRed.reduction_table_handling.reduction_table_handler import ReductionTableHandler
 
 
 class UpdateReductionTableMetadata(object):
@@ -20,41 +19,18 @@ def update(self):
         q_range = lrdata.q_range
         lambda_range = lrdata.lambda_range
         incident_angle = lrdata.incident_angle
+        const_q = lrdata.const_q
 
         [qmin, qmax] = q_range
         str_qmin = "%.4f" % qmin
-        _item_min = QtWidgets.QTableWidgetItem(str_qmin)
-        _item_min.setFlags(QtCore.Qt.ItemIsSelectable | QtCore.Qt.ItemIsEnabled)
         str_qmax = "%.4f" % qmax
-        _item_max = QtWidgets.QTableWidgetItem(str_qmax)
-        _item_max.setFlags(QtCore.Qt.ItemIsSelectable | QtCore.Qt.ItemIsEnabled)
-
         [lmin, lmax] = lambda_range
-        _item_lmin = QtWidgets.QTableWidgetItem(str(lmin))
-        _item_lmin.setFlags(QtCore.Qt.ItemIsSelectable | QtCore.Qt.ItemIsEnabled)
-        _item_lmax = QtWidgets.QTableWidgetItem(str(lmax))
-        _item_lmax.setFlags(QtCore.Qt.ItemIsSelectable | QtCore.Qt.ItemIsEnabled)
-
-        incident_angle = incident_angle
         str_incident_angle = "%.2f" % incident_angle
-        _item_incident = QtWidgets.QTableWidgetItem(str_incident_angle)
-        _item_incident.setFlags(QtCore.Qt.ItemIsSelectable | QtCore.Qt.ItemIsEnabled)
-
-        parent.ui.reductionTable.setItem(row, ReductionTableColumnIndex.Q_MIN, _item_min)
-        parent.ui.reductionTable.setItem(row, ReductionTableColumnIndex.Q_MAX, _item_max)
-        parent.ui.reductionTable.setItem(row, ReductionTableColumnIndex.LAMBDA_MIN, _item_lmin)
-        parent.ui.reductionTable.setItem(row, ReductionTableColumnIndex.LAMBDA_MAX, _item_lmax)
-        parent.ui.reductionTable.setItem(row, ReductionTableColumnIndex.TWO_THETA, _item_incident)
 
-        const_q = lrdata.const_q
-        const_q_col = ReductionTableColumnIndex.CONST_Q_BINS
-        const_q_checkbox = parent.ui.reductionTable.cellWidget(row, const_q_col).findChild(QtWidgets.QCheckBox)
-        const_q_checkbox.setChecked(const_q)
-
-    def sortIntArray(self, _array):
-        [_element1, _element2] = _array
-        _element1 = int(_element1)
-        _element2 = int(_element2)
-        _element_min = min([_element1, _element2])
-        _element_max = max([_element1, _element2])
-        return [_element_min, _element_max]
+        handler = ReductionTableHandler(parent)
+        handler.set_table_item_text(row, ReductionTableColumnIndex.Q_MIN, str_qmin)
+        handler.set_table_item_text(row, ReductionTableColumnIndex.Q_MAX, str_qmax)
+        handler.set_table_item_text(row, ReductionTableColumnIndex.LAMBDA_MIN, str(lmin))
+        handler.set_table_item_text(row, ReductionTableColumnIndex.LAMBDA_MAX, str(lmax))
+        handler.set_table_item_text(row, ReductionTableColumnIndex.TWO_THETA, str_incident_angle)
+        handler.set_checkbox_state(row, ReductionTableColumnIndex.CONST_Q_BINS, const_q)

RefRed/configuration/loading_configuration.py

@@ -5,7 +5,7 @@
 from typing import Any
 
 # third party imports
-from qtpy import QtGui, QtCore, QtWidgets
+from qtpy import QtWidgets
 from qtpy.QtWidgets import QFileDialog
 
 # application imports
@@ -22,6 +22,7 @@
 )
 from RefRed.lconfigdataset import LConfigDataset
 from RefRed.plot.clear_plots import ClearPlots
+from RefRed.reduction_table_handling.reduction_table_handler import ReductionTableHandler
 from RefRed.status_message_handler import StatusMessageHandler
 from RefRed.tabledata import TableData
 from RefRed.utilities import str2bool
@@ -301,16 +302,8 @@ def clear_display(self):
         ClearPlots(parent=self.parent, is_data=True, is_norm=True, all_plots=True)
 
     def clear_reductionTable(self):
-        nbr_row = self.parent.ui.reductionTable.rowCount()
-        nbr_col = self.parent.ui.reductionTable.columnCount()
-        _brush_color = QtGui.QBrush()
-        _brush_color.setColor(QtCore.Qt.black)
-        for _row in range(nbr_row):
-            for _col in range(nbr_col):
-                table_item = self.parent.ui.reductionTable.item(_row, _col)
-                if table_item is not None:  # cell holds text rather than a widget (e.g. checkbox)
-                    table_item.setText("")
-                    table_item.setForeground(_brush_color)
+        reduction_table_handler = ReductionTableHandler(parent=self.parent)
+        reduction_table_handler.clear_reduction_table()
 
     def populate_reduction_table_from_lconfigdataset(self):
         PopulateReductionTable(parent=self.parent)

RefRed/initialization/gui.py

@@ -3,6 +3,7 @@
 import socket
 
 from RefRed import WINDOW_TITLE
+from RefRed.interfaces.mytablewidget import ReductionTableColumnIndex
 from RefRed.plot.all_plot_axis import AllPlotAxis
 from RefRed.gui_handling.gui_utility import GuiUtility
 from RefRed.gui_handling.update_plot_widget_status import UpdatePlotWidgetStatus
@@ -133,7 +134,7 @@ def set_main_table(self):
 
         for row_index in range(self.parent.REDUCTIONTABLE_MAX_ROWCOUNT):
             for col_index in range(len(self.column_widths)):
-                if col_index == 0:
+                if col_index == ReductionTableColumnIndex.PLOTTED:
                     _widget = QtWidgets.QCheckBox()
                     _widget.setChecked(False)
                     _widget.setEnabled(True)
@@ -144,13 +145,15 @@ def set_main_table(self):
                     _widget.stateChanged.connect(_signal_func)
 
                     parent.ui.reductionTable.setCellWidget(row_index, col_index, _widget)
-                elif (col_index == 1) or (col_index == 2):
+                elif (col_index == ReductionTableColumnIndex.DATA_RUN) or (
+                    col_index == ReductionTableColumnIndex.NORM_RUN
+                ):
                     _item = QtWidgets.QTableWidgetItem()
                     _flags = QtCore.Qt.ItemIsSelectable | QtCore.Qt.ItemIsEnabled | QtCore.Qt.ItemIsEditable
                     _item.setFlags(_flags)
                     parent.ui.reductionTable.setItem(row_index, col_index, _item)
 
-                elif col_index == 8:
+                elif col_index == ReductionTableColumnIndex.CONST_Q_BINS:
                     # Create checkbox
                     _widget = QtWidgets.QCheckBox()
                     _widget.setChecked(False)

RefRed/reduction_table_handling/reduction_table_handler.py

@@ -1,12 +1,12 @@
 # standard imports
 
 # third party imports
-from qtpy import QtWidgets, QtCore
-from qtpy.QtCore import Qt  # type: ignore
+from qtpy import QtCore, QtGui, QtWidgets
 
 # application imports
 from RefRed import WINDOW_TITLE
 from RefRed.gui_handling.gui_utility import GuiUtility
+from RefRed.interfaces.mytablewidget import ReductionTableColumnIndex
 from RefRed.plot.clear_plots import ClearPlots
 from RefRed.tabledata import TableData
 
@@ -18,10 +18,11 @@ class ReductionTableHandler(object):
 
     def __init__(self, parent=None):
         self.parent = parent
+        self.table = parent.ui.reductionTable
 
     def full_clear(self):
         self.__clear_big_table_data()
-        self.__clear_reduction_table()
+        self.clear_reduction_table()
         self.__clear_metadata()
         self.__clear_plots()
         self.__reset_default_config_file_name()
@@ -39,73 +40,39 @@ def clear_rows_selected(self):
             self.__clear_plots()
         self.__clear_rows_big_table_data()
         self.__clear_rows_reduction_table()
-        self.__shifs_none_empty_rows_reduction_table()
+        self.__shift_none_empty_rows_reduction_table()
         self.__to_do_if_table_empty()
 
     def __to_do_if_table_empty(self):
         """If the table is now empty, various reset algos"""
-        _cell_value = str(self.parent.ui.reductionTable.item(0, 1).text())
+        _cell_value = str(self.table.item(0, 1).text())
         if _cell_value == "":
             self.__reset_default_config_file_name()
 
     def __clear_rows_reduction_table(self):
         _from_row = self.from_row
         _to_row = self.to_row
-        _nbr_col = self.parent.ui.reductionTable.columnCount()
+        _nbr_col = self.table.columnCount()
         for row_index in range(_from_row, _to_row + 1):
             for col_index in range(_nbr_col):
-                if col_index == 0:
-                    _widget = QtWidgets.QCheckBox()
-                    _widget.setChecked(False)
-                    _widget.setEnabled(True)
-                    _sig_func = lambda state=0, row=row_index: self.parent.reduction_table_visibility_changed_test(  # noqa: E501, E731
-                        state, row
-                    )
-                    _widget.stateChanged.connect(_sig_func)
-                    self.parent.ui.reductionTable.setCellWidget(row_index, col_index, _widget)
-
-                elif (col_index == 1) or (col_index == 2):
-                    _item = QtWidgets.QTableWidgetItem()
-                    _item.setFlags(QtCore.Qt.ItemIsSelectable | QtCore.Qt.ItemIsEnabled | QtCore.Qt.ItemIsEditable)
-                    self.parent.ui.reductionTable.setItem(row_index, col_index, _item)
-
-                else:
-                    _item = QtWidgets.QTableWidgetItem()
-                    _item.setFlags(QtCore.Qt.ItemIsSelectable | QtCore.Qt.ItemIsEnabled)
-                    self.parent.ui.reductionTable.setItem(row_index, col_index, _item)
-
-    def __shifs_none_empty_rows_reduction_table(self):
+                self.__clear_reduction_table_cell(row_index, col_index)
+
+    def __shift_none_empty_rows_reduction_table(self):
+        """Shift rows in the reduction table to eliminate empty rows"""
         _nbr_row = self.parent.REDUCTIONTABLE_MAX_ROWCOUNT
         _to_row = self.to_row
         if _to_row == (_nbr_row - 1):
             return
 
         _from_row = self.from_row
         _row_offset = 0
-        _nbr_col = self.parent.ui.reductionTable.columnCount()
+        _nbr_col = self.table.columnCount()
         for row_index in range(_to_row + 1, _nbr_row):
             _target_row_index = _from_row + _row_offset
             for col_index in range(_nbr_col):
-                if col_index == 0:
-                    _widget = self.parent.ui.reductionTable.cellWidget(_target_row_index, col_index)
-                    _widget.setChecked(self.__is_row_selected_checked(row_index))
-                else:
-                    _cell_value = self.parent.ui.reductionTable.item(row_index, col_index).text()
-                    self.parent.ui.reductionTable.item(_target_row_index, col_index).setText(_cell_value)
+                self.__copy_reduction_table_cell_value(row_index, _target_row_index, col_index)
             _row_offset += 1
 
-    def __is_row_selected_checked(self, row_selected):
-        _widget = self.parent.ui.reductionTable.cellWidget(row_selected, 0)
-        current_state = _widget.checkState()
-        if current_state == Qt.Unchecked:
-            return False
-        else:
-            return True
-
-    def __get_checkbox_signal_function(self, row_index):
-        root_function_name = "self.parent.reduction_table_visibility_changed_" + str(row_index)
-        return root_function_name
-
     def __clear_rows_big_table_data(self):
         r"""Delete rows with indexes in the range [self.from_row, self.to_row]
 
@@ -125,7 +92,7 @@ def __is_row_displayed_in_range_selected(self):
         return False
 
     def __get_range_row_selected(self):
-        selected_range = self.parent.ui.reductionTable.selectedRanges()
+        selected_range = self.table.selectedRanges()
         self.to_row = selected_range[0].bottomRow()
         self.from_row = selected_range[0].topRow()
 
@@ -155,14 +122,109 @@ def __clear_plots(self):
             plot_ix=True,
         )
 
-    def __clear_reduction_table(self):
-        nbr_row = self.parent.ui.reductionTable.rowCount()
-        nbr_col = self.parent.ui.reductionTable.columnCount()
+    def clear_reduction_table(self):
+        nbr_row = self.table.rowCount()
+        nbr_col = self.table.columnCount()
         for _row in range(nbr_row):
-            for _col in range(1, nbr_col):
-                table_item = self.parent.ui.reductionTable.item(_row, _col)
-                if table_item is not None:  # cell holds text rather than a widget (e.g. checkbox)
-                    table_item.setText("")
+            for _col in range(1, nbr_col):  # skips first column: plotted checkbox
+                self.__clear_reduction_table_cell(_row, _col)
 
     def __clear_big_table_data(self):
         self.parent.big_table_data = TableData(self.parent.REDUCTIONTABLE_MAX_ROWCOUNT)
+
+    def __copy_reduction_table_cell_value(self, from_row, to_row, col):
+        """Copy the table cell value from one row to another in the same column"""
+        # copy cell containing text
+        from_item = self.__get_table_cell_item(from_row, col)
+        to_item = self.__get_table_cell_item(to_row, col)
+        if from_item and to_item:
+            text = from_item.text()
+            text_foreground = from_item.foreground()
+            to_item.setText(text)
+            to_item.setForeground(text_foreground)
+        # copy cell containing checkbox
+        from_checkbox = self.__get_table_cell_checkbox_widget(from_row, col)
+        to_checkbox = self.__get_table_cell_checkbox_widget(to_row, col)
+        if from_checkbox and to_checkbox:
+            checked = from_checkbox.isChecked()
+            to_checkbox.setChecked(checked)
+
+    def __clear_reduction_table_cell(self, row: int, col: int):
+        """
+        Clear the reduction table cell given by row and col
+        - cells containing a QTableWidgetItem are set to empty string
+        - cells containing a QCheckBox are set as unchecked
+        """
+        item = self.__get_table_cell_item(row, col)
+        if item:
+            item.setText("")
+            item.setForeground(QtGui.QBrush(QtCore.Qt.black))  # type: ignore
+            item.setBackground(QtGui.QBrush())  # reset to default color
+            if col in (ReductionTableColumnIndex.DATA_RUN, ReductionTableColumnIndex.NORM_RUN):
+                flags = QtCore.Qt.ItemIsEditable | QtCore.Qt.ItemIsSelectable | QtCore.Qt.ItemIsEnabled  # type: ignore
+            else:
+                flags = QtCore.Qt.ItemIsSelectable | QtCore.Qt.ItemIsEnabled  # type: ignore
+            item.setFlags(flags)
+        checkbox_widget = self.__get_table_cell_checkbox_widget(row, col)
+        if checkbox_widget:
+            checkbox_widget.setChecked(False)
+            checkbox_widget.setEnabled(True)
+
+    def set_table_item_text(self, row: int, col: int, text: str):
+        """
+        Set the text in the reduction table cell given by row and col
+
+        Parameters
+        ----------
+        row: int
+        col: int
+        text: str
+
+        Raises
+        ------
+        ValueError
+            If the cell does not contain a QTableWidgetItem
+        """
+        item = self.__get_table_cell_item(row, col)
+        if item is None:
+            raise ValueError("Reduction table cell does not contain a QTableWidgetItem")
+        item.setText(text)
+
+    def __get_table_cell_item(self, row, col):
+        """Get QTableWidgetItem in the reduction table cell given by row and col"""
+        return self.table.item(row, col)
+
+    def __get_table_cell_checkbox_widget(self, row, col):
+        """
+        Get QCheckBox widget in the reduction table cell given by row and col,
+        whether it's the topmost cell widget or a child of the cell widget
+        """
+        cell_widget = self.table.cellWidget(row, col)
+        if cell_widget is None:
+            return None
+        # check if the cell widget is a checkbox
+        if isinstance(cell_widget, QtWidgets.QCheckBox):
+            return cell_widget
+        # check if the cell widget has a checkbox as a child
+        checkbox = cell_widget.findChild(QtWidgets.QCheckBox)
+        return checkbox
+
+    def set_checkbox_state(self, row: int, col: int, checked: bool):
+        """
+        Set the state of the checkbox in the reduction table cell given by row and col
+
+        Parameters
+        ----------
+        row: int
+        col: int
+        checked: bool
+
+        Raises
+        ------
+        ValueError
+            If the cell does not contain a QCheckBox
+        """
+        checkbox = self.__get_table_cell_checkbox_widget(row, col)
+        if checkbox is None:
+            raise ValueError("Reduction table cell does not contain a QCheckBox")
+        checkbox.setChecked(checked)