Filtering enabled! (#63)

* Filtering enabled!

* adding numpy import

* Fixed crash due to layoutChanged.emit()

* Removed further layoutChanged.emit() instances

Author: PaulJonasJost

src/petab_gui/controllers/mother_controller.py

@@ -292,12 +292,12 @@ def setup_actions(self):
         filter_layout = QHBoxLayout()
         filter_layout.setContentsMargins(0, 0, 0, 0)
         filter_widget.setLayout(filter_layout)
-        filter_input = QLineEdit()
-        filter_input.setPlaceholderText("Filter not functional yet ...")
-        filter_layout.addWidget(filter_input)
+        self.filter_input = QLineEdit()
+        self.filter_input.setPlaceholderText("Filter not functional yet ...")
+        filter_layout.addWidget(self.filter_input)
         for table_n, table_name in zip(
-            ["m", "p", "o", "c", "x"],
-            ["Measurement", "Parameter", "Observable", "Condition", "SBML"]
+            ["m", "p", "o", "c"],
+            ["measurement", "parameter", "observable", "condition"]
         ):
             tool_button = QToolButton()
             icon = qta.icon(
@@ -312,7 +312,11 @@ def setup_actions(self):
             tool_button.setToolTip(f"Filter for {table_name}")
             filter_layout.addWidget(tool_button)
             self.filter_active[table_name] = tool_button
+            self.filter_active[table_name].toggled.connect(
+                self.filter_table
+            )
         actions["filter_widget"] = filter_widget
+        self.filter_input.textChanged.connect(self.filter_table)
 
         # show/hide elements
         for element in ["measurement", "observable", "parameter", "condition"]:
@@ -707,6 +711,17 @@ def delete_column(self):
         if controller:
             controller.delete_column()
 
+    def filter_table(self):
+        """Filter the currently activated tables"""
+        filter_text = self.filter_input.text()
+        for table_name, tool_button in self.filter_active.items():
+            if tool_button.isChecked():
+                controller = getattr(self, f"{table_name}_controller")
+                controller.filter_table(filter_text)
+            else:
+                controller = getattr(self, f"{table_name}_controller")
+                controller.remove_filter()
+
     def copy_to_clipboard(self):
         controller = self.active_controller()
         if controller:

src/petab_gui/controllers/table_controllers.py

@@ -4,7 +4,7 @@
 import numpy as np
 import pandas as pd
 import petab.v1 as petab
-from PySide6.QtCore import Signal, QObject, QModelIndex, QPoint
+from PySide6.QtCore import Signal, QObject, QModelIndex, Qt
 from pathlib import Path
 from ..models.pandas_table_model import PandasTableModel, \
     PandasTableFilterProxy
@@ -48,7 +48,7 @@ def __init__(
         self.logger = logger
         self.check_petab_lint_mode = True
         self.mother_controller = mother_controller
-        self.view.table_view.setModel(self.model)
+        self.view.table_view.setModel(self.proxy_model)
         self.setup_connections()
         self.setup_connections_specific()
 
@@ -160,12 +160,16 @@ def overwrite_df(self, new_df: pd.DataFrame):
         # TODO: Mother controller connects to overwritten_df signal. Set df
         #  in petabProblem and unsaved changes to True
         """Overwrite the DataFrame of the model with the data from the view."""
+        self.proxy_model.setSourceModel(None)
+        self.model.beginResetModel()
         self.model._data_frame = new_df
-        self.model.layoutChanged.emit()
+        self.model.beginResetModel()
         self.logger.log_message(
             f"Overwrote the {self.model.table_type} table with new data.",
             color="green"
         )
+        # test: overwrite the new model as source model
+        self.proxy_model.setSourceModel(self.model)
         self.overwritten_df.emit()
 
     def append_df(self, new_df: pd.DataFrame):
@@ -175,17 +179,20 @@ def append_df(self, new_df: pd.DataFrame):
             1. Columns are the union of both DataFrame columns.
             2. Rows are the union of both DataFrame rows (duplicates removed)
         """
-        self.model._data_frame = pd.concat(
+        self.model.beginResetModel()
+        combined_df = pd.concat(
             [self.model.get_df(), new_df], axis=0
         )
-        self.model._data_frame = self.model._data_frame[
-            ~self.model._data_frame.index.duplicated(keep="first")
-        ]
-        self.model.layoutChanged.emit()
+        combined_df = combined_df[~combined_df.index.duplicated(keep="first")]
+        self.model._data_frame = combined_df
+        self.proxy_model.setSourceModel(None)
+        self.proxy_model.setSourceModel(self.model)
+        self.model.endResetModel()
         self.logger.log_message(
             f"Appended the {self.model.table_type} table with new data.",
             color="green"
         )
+        # test: overwrite the new model as source model
         self.overwritten_df.emit()
 
     def clear_table(self):
@@ -271,6 +278,16 @@ def set_index_on_new_row(self, index: QModelIndex):
         """Set the index of the model when a new row is added."""
         self.view.table_view.setCurrentIndex(index)
 
+    def filter_table(self, text):
+        """Filter the table."""
+        self.proxy_model.setFilterRegularExpression(text)
+        self.proxy_model.setFilterKeyColumn(-1)
+
+    def remove_filter(self):
+        """Remove the filter from the table."""
+        self.proxy_model.setFilterRegularExpression("")
+        self.proxy_model.setFilterKeyColumn(-1)
+
     def copy_to_clipboard(self):
         """Copy the currently selected cells to the clipboard."""
         self.view.copy_to_clipboard()
@@ -322,13 +339,25 @@ def rename_value(self, old_id: str, new_id: str, column_names: str | list[str]):
         """
         if not isinstance(column_names, list):
             column_names = [column_names]
-        rows = self.model.get_df().shape[0]
-        for row in range(rows):
-            for column_name in column_names:
-                if self.model._data_frame.at[row, column_name] == old_id:
-                    self.model._data_frame.at[row, column_name] = new_id
-        self.model.something_changed.emit(True)
-        self.model.layoutChanged.emit()
+
+        # Find occurences
+        mask = self.model._data_frame[column_names].eq(old_id)
+        if mask.any().any():
+            self.model._data_frame.loc[mask] = new_id
+            changed_rows = mask.any(axis=1)
+            first_row, last_row = (
+                changed_rows.idxmax(), changed_rows[::-1].idxmax()
+            )
+            top_left = self.model.index(first_row, 1)
+            bottom_right = self.model.index(
+                last_row, self.model.columnCount() - 1
+            )
+            self.model.dataChanged.emit(
+                top_left, bottom_right, [Qt.DisplayRole, Qt.EditRole]
+            )
+
+            # Emit change signal
+            self.model.something_changed.emit(True)
 
     def copy_noise_parameters(
         self,

src/petab_gui/models/pandas_table_model.py

@@ -4,7 +4,8 @@
 from PySide6.QtGui import QColor
 
 from ..C import COLUMNS
-from ..utils import validate_value, create_empty_dataframe, is_invalid, get_selected
+from ..utils import validate_value, create_empty_dataframe, is_invalid, \
+    get_selected
 
 
 class PandasTableModel(QAbstractTableModel):
@@ -47,7 +48,7 @@ def data(self, index, role=Qt.DisplayRole):
             if column == 0:
                 value = self._data_frame.index[row]
                 return str(value)
-            value = self._data_frame.iloc[row, column-1]
+            value = self._data_frame.iloc[row, column - 1]
             if is_invalid(value):
                 return ""
             return str(value)
@@ -118,7 +119,8 @@ def insertColumn(self, column_name: str):
             )
         position = self._data_frame.shape[1]
         self.beginInsertColumns(QModelIndex(), position, position)
-        column_type = self._allowed_columns.get(column_name, {"type": "STRING"})["type"]
+        column_type = \
+        self._allowed_columns.get(column_name, {"type": "STRING"})["type"]
         default_value = "" if column_type == "STRING" else 0
         self._data_frame[column_name] = default_value
         self.endInsertColumns()
@@ -148,7 +150,6 @@ def _set_data_single(self, index, value):
         if index.row() == self._data_frame.shape[0]:
             # empty row at the end
             self.insertRows(index.row(), 1)
-            self.layoutChanged.emit()
             next_index = self.index(index.row(), 0)
             self.inserted_row.emit(next_index)
         if index.column() == 0 and self._has_named_index:
@@ -177,7 +178,8 @@ def _set_data_single(self, index, value):
             self.cell_needs_validation.emit(row, column)
             self.something_changed.emit(True)
             return True
-        if column_name in ["conditionId", "simulationConditionId", "preequilibrationConditionId"]:
+        if column_name in ["conditionId", "simulationConditionId",
+                           "preequilibrationConditionId"]:
             self._data_frame.iloc[row, column - col_setoff] = value
             self.dataChanged.emit(index, index, [Qt.DisplayRole])
             self.relevant_id_changed.emit(value, old_value, "condition")
@@ -214,11 +216,31 @@ def handle_named_index(self, index, value):
 
     def replace_text(self, old_text: str, new_text: str):
         """Replace text in the table."""
-        self._data_frame.replace(old_text, new_text, inplace=True)
+        # find all occurences of old_text and sae indices
+        mask = self._data_frame.eq(old_text)
+        if mask.any().any():
+            self._data_frame.replace(old_text, new_text, inplace=True)
+            # Get first and last modified cell for efficient `dataChanged` emit
+            changed_cells = mask.stack()[
+                mask.stack()].index.tolist()  # Extract (row, col) pairs
+            if changed_cells:
+                first_row, first_col = changed_cells[0]
+                last_row, last_col = changed_cells[-1]
+                if self._has_named_index:
+                    first_col += 1
+                    last_col += 1
+                top_left = self.index(first_row, first_col)
+                bottom_right = self.index(last_row, last_col)
+                self.dataChanged.emit(top_left, bottom_right, [Qt.DisplayRole])
         # also replace in the index
-        if self._has_named_index:
+        if self._has_named_index and old_text in self._data_frame.index:
             self._data_frame.rename(index={old_text: new_text}, inplace=True)
-        self.layoutChanged.emit()
+            index_row = self._data_frame.index.get_loc(new_text)
+            index_top_left = self.index(index_row, 0)
+            index_bottom_right = self.index(index_row, 0)
+            self.dataChanged.emit(
+                index_top_left, index_bottom_right, [Qt.DisplayRole]
+            )
 
     def get_df(self):
         """Return the DataFrame."""
@@ -332,10 +354,16 @@ def check_selection(self):
         return len(rows) > 1 and len(cols) == 1, selected
 
     def reset_invalid_cells(self):
-        """Reset the invalid cells."""
-        self._invalid_cells = set()
-        self.layoutChanged.emit()
+        """Reset the invalid cells and update their background color."""
+        if not self._invalid_cells:
+            return
+
+        invalid_cells = list(self._invalid_cells)
+        self._invalid_cells.clear()  # Clear invalid cells set
 
+        for row, col in invalid_cells:
+            index = self.index(row, col)
+            self.dataChanged.emit(index, index, [Qt.BackgroundRole])
     def mimeData(self, rectangle, start_index):
         """Return the data to be copied to the clipboard.
 
@@ -528,6 +556,7 @@ def return_column_index(self, column_name):
 
 class ObservableModel(IndexedPandasTableModel):
     """Table model for the observable data."""
+
     def __init__(self, data_frame, parent=None):
         super().__init__(
             data_frame=data_frame,
@@ -562,6 +591,7 @@ def fill_row(self, row_position: int, data: dict):
 
 class ParameterModel(IndexedPandasTableModel):
     """Table model for the parameter data."""
+
     def __init__(self, data_frame, parent=None):
         super().__init__(
             data_frame=data_frame,
@@ -573,6 +603,7 @@ def __init__(self, data_frame, parent=None):
 
 class ConditionModel(IndexedPandasTableModel):
     """Table model for the condition data."""
+
     def __init__(self, data_frame, parent=None):
         super().__init__(
             data_frame=data_frame,
@@ -610,36 +641,22 @@ def __init__(self, model, parent=None):
         super().__init__(parent)
         self.source_model = model
         self.setSourceModel(model)
-        self.column_filters = {}  # Store filters for multiple columns
-
-    def setFilterForColumn(self, column, pattern):
-        """Set filter pattern for a specific column."""
-        if pattern:
-            self.column_filters[column] = pattern  # Add or update filter for the column
-        else:
-            self.column_filters.pop(column, None)  # Remove filter if pattern is empty
-        self.invalidateFilter()  # Trigger the proxy to re-evaluate the filters
 
     def filterAcceptsRow(self, source_row, source_parent):
-        """Custom filtering logic to apply filters on multiple columns."""
+        """Custom filtering logic to apply global filtering across all columns."""
         source_model = self.sourceModel()
 
         # Always accept the last row (for "add new row")
         if source_row == source_model.rowCount() - 1:
             return True
 
-        # Apply all column filters
-        for column, pattern in self.column_filters.items():
-            index = source_model.index(source_row, column, source_parent)
-            value = source_model.data(index, Qt.DisplayRole)
-            if not self.valueMatchesFilter(value, pattern):
-                return False  # Reject the row if any column doesn't match its filter
-
-        return True  # Accept row if it matches all filters
-
-    def valueMatchesFilter(self, value, pattern):
-        """Check if the value matches the filter pattern."""
-        if pattern and pattern not in str(value):
-            return False
-        return True
+        regex = self.filterRegularExpression()
+        if regex.pattern() == "":
+            return True
 
+        for column in range(source_model.columnCount()):
+            index = source_model.index(source_row, column, QModelIndex())
+            data_str = str(source_model.data(index) or "")
+            if regex.match(data_str).hasMatch():
+                return True
+        return False  # No match found