correcting_column_targeting (#70)

* Removed bug where we deleted wrong column due to index offset

* Only allow deletion of optional columns

* Fixed bug where columns where not deleted but invalid cells was still wrongly updated

* Added a tableviewer class that handles column resizing

* Fix bug in conflict resolve.

Author: PaulJonasJost

src/petab_gui/controllers/table_controllers.py

@@ -170,6 +170,8 @@ def overwrite_df(self, new_df: pd.DataFrame):
         )
         # test: overwrite the new model as source model
         self.proxy_model.setSourceModel(self.model)
+        # change default sizing
+        self.view.table_view.reset_column_sizes()
         self.overwritten_df.emit()
 
     def append_df(self, new_df: pd.DataFrame):
@@ -210,12 +212,12 @@ def delete_row(self):
         for row in sorted(selected_rows, reverse=True):
             if row >= self.model.rowCount() - 1:
                 continue
+            self.model.delete_row(row)
             self.logger.log_message(
                 f"Deleted row {row} from {self.model.table_type} table."
                 f" Data: {self.model.get_df().iloc[row].to_dict()}",
                 color="orange"
             )
-            self.model.delete_row(row)
         self.model.something_changed.emit(True)
 
     def add_row(self):
@@ -240,19 +242,27 @@ def delete_column(self):
         selected_columns = get_selected(table_view, mode=COLUMN)
         if not selected_columns:
             return
-        self.model.update_invalid_cells(selected_columns, mode="columns")
+        deleted_columns = set()
         for column in sorted(selected_columns, reverse=True):
             # safely delete potential item delegates
-            column_name = self.model.get_df().columns[column]
+            allow_del, column_name = self.model.allow_column_deletion(column)
+            if not allow_del:
+                self.logger.log_message(
+                    f"Cannot delete column {column_name}, as it is a "
+                    f"required column!",
+                    color = "red"
+                )
+                continue
             if column_name in self.completers:
                 self.view.table_view.setItemDelegateForColumn(column, None)
                 del self.completers[column_name]
-            column_name = self.model.get_df().columns[column]
+            self.model.delete_column(column)
             self.logger.log_message(
                 f"Deleted column '{column_name}' from {self.model.table_type} table.",
                 color="orange"
             )
-            self.model.delete_column(column)
+            deleted_columns.add(column)
+        self.model.update_invalid_cells(deleted_columns, mode="columns")
         self.model.something_changed.emit(True)
 
     def add_column(self, column_name: str = None):

src/petab_gui/models/pandas_table_model.py

@@ -28,12 +28,15 @@ def __init__(self, data_frame, allowed_columns, table_type, parent=None):
         self._data_frame = data_frame
         # add a view here, access is needed for selectionModels
         self.view = None
+        # offset for row and column to get from the data_frame to the view
+        self.row_index_offset = 0
+        self.column_offset = 0
 
     def rowCount(self, parent=QModelIndex()):
         return self._data_frame.shape[0] + 1  # empty row at the end
 
     def columnCount(self, parent=QModelIndex()):
-        return self._data_frame.shape[1] + 1  # measurement needs other
+        return self._data_frame.shape[1] + self.column_offset
 
     def data(self, index, role=Qt.DisplayRole):
         """Return the data at the given index and role for the View."""
@@ -275,6 +278,8 @@ def discard_invalid_cell(self, row, column):
 
     def update_invalid_cells(self, selected, mode: str = "rows"):
         """Edits the invalid cells when values are deleted."""
+        if not selected:
+            return
         old_invalid_cells = self._invalid_cells.copy()
         new_invalid_cells = set()
         sorted_to_del = sorted(selected)
@@ -312,10 +317,8 @@ def get_value_from_column(self, column_name, row):
         return ""
 
     def return_column_index(self, column_name):
-        """Return the index of a column."""
-        if column_name in self._data_frame.columns:
-            return self._data_frame.columns.get_loc(column_name) + 1
-        return -1
+        """Return the index of a column. Defined in Subclasses"""
+        pass
 
     def unique_values(self, column_name):
         """Return the unique values in a column."""
@@ -333,8 +336,8 @@ def delete_row(self, row):
 
     def delete_column(self, column_index):
         """Delete a column from the DataFrame."""
+        column_name = self._data_frame.columns[column_index - self.column_offset]
         self.beginRemoveColumns(QModelIndex(), column_index, column_index)
-        column_name = self._data_frame.columns[column_index]
         self._data_frame.drop(columns=[column_name], inplace=True)
         self.endRemoveColumns()
 
@@ -437,6 +440,15 @@ def determine_background_color(self, row, column):
             return QColor(144, 190, 109, 102)
         return QColor(177, 217, 231, 102)
 
+    def allow_column_deletion(self, column: int) -> bool:
+        """Checks whether the column can safely be deleted"""
+        if column == 0 and self._has_named_index:
+            return False, self._data_frame.index.name
+        column_name = self._data_frame.columns[column-self.column_offset]
+        if column_name not in self._allowed_columns.keys():
+            return True, column_name
+        return self._allowed_columns[column_name]["optional"], column_name
+
 
 class IndexedPandasTableModel(PandasTableModel):
     """Table model for tables with named index."""
@@ -450,6 +462,7 @@ def __init__(self, data_frame, allowed_columns, table_type, parent=None):
             parent=parent
         )
         self._has_named_index = True
+        self.column_offset = 1
 
     def handle_named_index(self, index, value):
         """Handle the named index column."""
@@ -499,9 +512,6 @@ def __init__(self, data_frame, parent=None):
             parent=parent
         )
 
-    def columnCount(self, parent=QModelIndex()):
-        return self._data_frame.shape[1]
-
     def data(self, index, role=Qt.DisplayRole):
         """Return the data at the given index and role for the View."""
         if not index.isValid():

src/petab_gui/views/table_view.py

@@ -1,7 +1,8 @@
-from PySide6.QtWidgets import QDockWidget, QVBoxLayout, QTableView, QWidget,\
-    QCompleter, QLineEdit, QStyledItemDelegate, QComboBox
-from PySide6.QtCore import Qt
-from PySide6.QtGui import QGuiApplication
+from PySide6.QtWidgets import (QDockWidget, QHeaderView, QTableView,
+                               QCompleter, QLineEdit, QStyledItemDelegate,
+                               QComboBox)
+from PySide6.QtCore import Qt, QPropertyAnimation, QRect
+from PySide6.QtGui import QGuiApplication, QColor
 
 from ..utils import get_selected, get_selected_rectangles
 from ..C import INDEX
@@ -15,13 +16,9 @@ def __init__(self, title, parent=None):
         self.setAllowedAreas(
             Qt.AllDockWidgetAreas
         )
-        widget = QWidget()
-        self.setWidget(widget)
-        layout = QVBoxLayout(widget)
-
         # Create the QTableView for the table content
-        self.table_view = QTableView()
-        layout.addWidget(self.table_view)
+        self.table_view = CustomTableView()
+        self.setWidget(self.table_view)
         # Dictionary to store column-specific completers
         self.completers = {}
         self.table_view.setAlternatingRowColors(True)
@@ -48,7 +45,8 @@ def paste_from_clipboard(self):
         model = self.table_view.model()
         row_start, col_start = start_index.row(), start_index.column()
         # identify which invalid cells are being pasted into
-        pasted_data = [line.split("\t") for line in text.split("\n") if line.strip()]
+        pasted_data = [line.split("\t") for line in text.split("\n") if
+                       line.strip()]
         num_rows = len(pasted_data)
         num_cols = max([len(line) for line in pasted_data])
         overridden_cells = {
@@ -85,6 +83,7 @@ def createEditor(self, parent, option, index):
 class SingleSuggestionDelegate(QStyledItemDelegate):
     """Suggest a single option based the current row and the value in
     `column_name`."""
+
     def __init__(self, model, suggestions_column, afix=None, parent=None):
         super().__init__(parent)
         self.model = model  # The main model to retrieve data from
@@ -110,6 +109,7 @@ def createEditor(self, parent, option, index):
 
         return editor
 
+
 class ColumnSuggestionDelegate(QStyledItemDelegate):
     """Suggest options based on all unique values in the specified column."""
     def __init__(
@@ -171,3 +171,95 @@ def createEditor(self, parent, option, index):
         editor.setCompleter(completer)
 
         return editor
+
+
+class CustomTableView(QTableView):
+    """Custom Table View to Handle Copy Paste events, resizing policies etc."""
+
+    def __init__(self, parent=None):
+        super().__init__(parent)
+        self.setSizeAdjustPolicy(QTableView.AdjustToContents)
+        self.horizontalHeader().setSectionResizeMode(
+            QHeaderView.ResizeToContents
+        )
+        self.horizontalHeader().setStretchLastSection(
+            False
+        )  # Prevent last column from stretching
+
+        self.horizontalHeader().sectionDoubleClicked.connect(
+            self.autofit_column
+        )
+
+    def setModel(self, model):
+        """Ensures selection model exists before connecting signals"""
+        super().setModel(model)
+        if self.selectionModel():
+            self.selectionModel().currentColumnChanged.connect(self.highlight_active_column)
+
+    def reset_column_sizes(self):
+        """Resets column sizes with refinements"""
+        header = self.horizontalHeader()
+        total_width = self.viewport().width()
+        max_width = total_width // 4  # 1/4th of total table width
+
+        header.setSectionResizeMode(QHeaderView.ResizeToContents)
+        self.resizeColumnsToContents()
+        header.setSectionResizeMode(QHeaderView.Interactive)
+
+        # Enforce max width but allow expanding into empty neighbors
+        for col in range(self.model().columnCount()):
+            optimal_width = self.columnWidth(col)
+            if optimal_width > max_width:
+                self.setColumnWidth(col, max_width)
+            else:
+                self.setColumnWidth(col, optimal_width)
+
+        # self.adjust_for_empty_neighbors()
+        self.collapse_empty_columns()
+        self.updateGeometry()
+
+    def adjust_for_empty_neighbors(self):
+        """Expands column if adjacent columns are empty"""
+        model = self.model()
+        for col in range(model.columnCount()):
+            if self.columnWidth(col) == self.viewport().width() // 4:  # If maxed out
+                next_col = col + 1
+                if next_col < model.columnCount():
+                    if all(model.index(row, next_col).data() in [None, ""] for row in range(model.rowCount())):
+                        new_width = self.columnWidth(
+                            col) + self.columnWidth(next_col)
+                        self.setColumnWidth(col, new_width)
+                        self.setColumnWidth(next_col, 0)  # Hide empty column
+
+    def collapse_empty_columns(self):
+        """Collapses columns that only contain empty values"""
+        model = self.model()
+        for col in range(model.columnCount()):
+            if all(model.index(row, col).data() in [None, "", " "] for row in
+                   range(model.rowCount())):
+                self.setColumnWidth(col, 10)  # Minimal width
+
+    def autofit_column(self, col):
+        """Expands column width on double-click"""
+        self.horizontalHeader().setSectionResizeMode(col,
+                                                     QHeaderView.ResizeToContents)
+        self.resizeColumnToContents(col)
+        self.horizontalHeader().setSectionResizeMode(col,
+                                                     QHeaderView.Interactive)
+
+    def highlight_active_column(self, index):
+        """Highlights the active column"""
+        for row in range(self.model().rowCount()):
+            self.model().setData(self.model().index(row, index.column()),
+                                 QColor("#cce6ff"), Qt.BackgroundRole)
+
+    def animate_column_resize(self, col, new_width):
+        """Smoothly animates column resizing"""
+        anim = QPropertyAnimation(self, b"geometry")
+        anim.setDuration(200)
+        anim.setStartValue(QRect(self.columnViewportPosition(col), 0,
+                                 self.columnWidth(col), self.height()))
+        anim.setEndValue(
+            QRect(self.columnViewportPosition(col), 0, new_width,
+                  self.height()))
+        anim.start()