default_values (#55)

* Default values for parameter table

* Added default configuration as option (mainly for condition table

* Added default configuration for condition table

* Fixed a bug when adding new columns

* Added DEfault values to observables

* Added Interface to ask for condition ID in Uploading datamatrix

* Adding a new row due to automatic addition of condition or observable also fills the defaults now

* No majority vote on condition files

* Created a settings manager, loading and saving settings to manager.

* Unified settings to also include recent files

* static method

* moved default configurations to settings manager

* Default values can be now changed and applied.

* fixed typo that lead to warnings

* Settings slightly adapted for now!

* Adapted changes to handler

* intermediate

* Limit choice for some columns. Apply index defaults also to par and cond tables. Allow defaults for meas table

Author: PaulJonasJost

src/petab_gui/C.py

@@ -59,4 +59,117 @@
 # String constants
 ROW = 'row'
 COLUMN = 'column'
-INDEX = 'index'
+INDEX = 'index'
+
+COPY_FROM = "copy from"
+USE_DEFAULT = "use default"
+NO_DEFAULT = "no default"
+MIN_COLUMN = "use column min"
+MAX_COLUMN = "use column max"
+MODE = "use most frequent"
+STRATEGIES_DEFAULT = [COPY_FROM, USE_DEFAULT, NO_DEFAULT]
+STRATEGIES_DEFAULT_EXT = STRATEGIES_DEFAULT + [MODE]
+STRATEGIES_DEFAULT_ALL = STRATEGIES_DEFAULT_EXT + [MIN_COLUMN, MAX_COLUMN]
+STRATEGY_TOOLTIP = {
+    COPY_FROM: "Copy from another column in the same row",
+    USE_DEFAULT: "Use default value",
+    NO_DEFAULT: "Do not set a value",
+    MIN_COLUMN: "Use the minimum value of the column",
+    MAX_COLUMN: "Use the maximum value of the column",
+    MODE: "Use the most frequent value of the column",
+}
+SOURCE_COLUMN = "source_column"
+DEFAULT_VALUE = "default_value"
+
+# Default Configurations of Default Values
+ALLOWED_STRATEGIES_OBS = {
+    "observableId": STRATEGIES_DEFAULT,
+    "observableName": STRATEGIES_DEFAULT,
+    "observableFormula": STRATEGIES_DEFAULT,
+    "observableTransformation": [USE_DEFAULT, NO_DEFAULT, MODE],
+    "noiseFormula": [COPY_FROM, USE_DEFAULT, NO_DEFAULT, MODE],
+    "noiseDistribution": [USE_DEFAULT, NO_DEFAULT, MODE],
+}
+ALLOWED_STRATEGIES_PAR = {
+    "parameterId": STRATEGIES_DEFAULT,
+    "parameterName": STRATEGIES_DEFAULT,
+    "parameterScale": [USE_DEFAULT, NO_DEFAULT, MODE],
+    "lowerBound": [MIN_COLUMN, MAX_COLUMN, USE_DEFAULT, NO_DEFAULT, MODE],
+    "upperBound": [MAX_COLUMN, MAX_COLUMN, USE_DEFAULT, NO_DEFAULT, MODE],
+    "nominalValue": [USE_DEFAULT, NO_DEFAULT],
+    "estimate": [USE_DEFAULT, NO_DEFAULT, MODE],
+}
+ALLOWED_STRATEGIES_COND = {
+    "conditionId": STRATEGIES_DEFAULT,
+    "conditionName": STRATEGIES_DEFAULT,
+}
+ALLOWED_STRATEGIES_MEAS = {
+    "observableId": STRATEGIES_DEFAULT,
+    "preequilibrationConditionId": STRATEGIES_DEFAULT_EXT,
+    "simulationConditionId": STRATEGIES_DEFAULT_EXT,
+    "time": [NO_DEFAULT, USE_DEFAULT, MODE],
+    "measurement": [NO_DEFAULT, USE_DEFAULT, MODE],
+    "observableParameters": STRATEGIES_DEFAULT_EXT,
+    "noiseParameters": STRATEGIES_DEFAULT_EXT,
+    "datasetId": [COPY_FROM, USE_DEFAULT, NO_DEFAULT, MODE],
+    "replicateId": [COPY_FROM, USE_DEFAULT, NO_DEFAULT, MODE],
+}
+ALLOWED_STRATEGIES = {
+    "observable": ALLOWED_STRATEGIES_OBS,
+    "parameter": ALLOWED_STRATEGIES_PAR,
+    "condition": ALLOWED_STRATEGIES_COND,
+    "measurement": ALLOWED_STRATEGIES_MEAS
+}
+DEFAULT_OBS_CONFIG = {
+    "observableId": {
+        "strategy": COPY_FROM, SOURCE_COLUMN: "observableFormula",
+        DEFAULT_VALUE: "new_observable"
+    },
+    "observableName": {
+        "strategy": COPY_FROM, SOURCE_COLUMN: "observableId"
+    },
+    "noiseFormula": {
+        "strategy": USE_DEFAULT, DEFAULT_VALUE: 1
+    },
+    "observableTransformation": {
+        "strategy": USE_DEFAULT,
+        DEFAULT_VALUE: "lin"
+    },
+    "noiseDistribution": {
+        "strategy": USE_DEFAULT,
+        DEFAULT_VALUE: "normal"
+    }
+}
+DEFAULT_PAR_CONFIG = {
+    "parameterName": {
+        "strategy": COPY_FROM, SOURCE_COLUMN: "parameterId",
+        DEFAULT_VALUE: "new_parameter"
+    },
+    "parameterScale": {
+        "strategy": USE_DEFAULT, DEFAULT_VALUE: "log10"
+    },
+    "lowerBound": {
+        "strategy": MIN_COLUMN
+    },
+    "upperBound": {
+        "strategy": MAX_COLUMN
+    },
+    "estimate": {
+        "strategy": USE_DEFAULT, DEFAULT_VALUE: 1
+    },
+}
+DEFAULT_COND_CONFIG = {
+    "conditionId": {
+        "strategy": USE_DEFAULT, DEFAULT_VALUE: "new_condition"
+    },
+    "conditionName": {
+        "strategy": COPY_FROM, SOURCE_COLUMN: "conditionId"
+    }
+}
+DEFAULT_MEAS_CONFIG = {}
+DEFAULT_CONFIGS = {
+    "observable": DEFAULT_OBS_CONFIG,
+    "parameter": DEFAULT_PAR_CONFIG,
+    "condition": DEFAULT_COND_CONFIG,
+    "measurement": DEFAULT_MEAS_CONFIG
+}

src/petab_gui/app.py

@@ -25,7 +25,7 @@ class PEtabGuiApp(QApplication):
     def __init__(self):
         super().__init__(sys.argv)
 
-        # Load the styleshee
+        # Load the stylesheet
         # self.apply_stylesheet()
         self.model = PEtabModel()
         self.view = MainWindow()

src/petab_gui/controllers/default_handler.py

@@ -0,0 +1,102 @@
+"""The Default Handlers for the GUI."""
+import pandas as pd
+import numpy as np
+import copy
+
+from collections import Counter
+from ..C import (COPY_FROM, USE_DEFAULT, NO_DEFAULT, MIN_COLUMN, MAX_COLUMN,
+                 MODE, DEFAULT_VALUE, SOURCE_COLUMN, STRATEGIES_DEFAULT)
+
+
+class DefaultHandlerModel:
+    def __init__(self, model, config):
+        """
+        Initialize the handler for the model.
+        :param model: The PandasTable Model containing the Data.
+        :param config: Dictionary containing strategies and settings for each column.
+        """
+        self._model = model
+        # TODO: Check what happens with non inplace operations
+        self.model = model._data_frame
+        self.config = config
+        self.model_index = self.model.index.name
+
+    def get_default(self, column_name, row_index=None):
+        """
+        Get the default value for a column based on its strategy.
+        :param column_name: The name of the column to compute the default for.
+        :param row_index: Optional index of the row (needed for some strategies).
+        :return: The computed default value.
+        """
+        source_column = column_name
+        if column_name not in self.config:
+            if "default_config" in self.config:
+                column_name = "default_config"
+            else:
+                return ""
+
+        column_config = self.config[column_name]
+        strategy = column_config.get("strategy", NO_DEFAULT)
+        default_value = column_config.get(DEFAULT_VALUE, "")
+
+        if strategy == USE_DEFAULT:
+            return default_value
+        elif strategy == NO_DEFAULT:
+            return ""
+        elif strategy == MIN_COLUMN:
+            return self._min_column(column_name)
+        elif strategy == MAX_COLUMN:
+            return self._max_column(column_name)
+        elif strategy == COPY_FROM:
+            return self._copy_column(column_name, column_config, row_index)
+        elif strategy == MODE:
+            column_config[SOURCE_COLUMN] = source_column
+            return self._majority_vote(column_name, column_config)
+        else:
+            raise ValueError(f"Unknown strategy '{strategy}' for column '{column_name}'.")
+
+    def _min_column(self, column_name):
+        if column_name in self.model:
+            column_data = self.model[column_name].replace("", np.nan).dropna()
+            if not column_data.empty:
+                return column_data.min()
+        return ""
+
+    def _max_column(self, column_name):
+        if column_name in self.model:
+            column_data = self.model[column_name].replace("", np.nan).dropna()
+            if not column_data.empty:
+                return column_data.max()
+        return ""
+
+    def _copy_column(self, column_name, config, row_index):
+        source_column = config.get(SOURCE_COLUMN, column_name)
+        source_column_valid = (
+            source_column in self.model or source_column == self.model_index
+        )
+        if source_column and source_column_valid and row_index is not None:
+            prefix = config.get("prefix", "")
+            if row_index in self.model.index:
+                if source_column == self.model_index:
+                    return f"{prefix}{row_index}"
+                value = f"{prefix}{self.model.at[row_index, source_column]}"
+                return value if pd.notna(value) else ""
+        return ""
+
+    def _majority_vote(self, column_name, config):
+        """Use the most frequent value in the column as the default.
+
+        Defaults to last used value in case of a tie.
+        """
+        source_column = config.get(SOURCE_COLUMN, column_name)
+        source_column_valid = (
+            source_column in self.model or source_column == self.model_index
+        )
+        if source_column and source_column_valid:
+            valid_values = copy.deepcopy(self.model[source_column][:-1])
+            valid_values = valid_values.iloc[::-1]
+            if valid_values.empty:
+                return ""
+            value_counts = Counter(valid_values)
+            return value_counts.most_common(1)[0][0]
+        return ""

src/petab_gui/controllers/mother_controller.py

@@ -21,6 +21,7 @@
 from ..views import TaskBar
 from .utils import prompt_overwrite_or_append, RecentFilesManager
 from functools import partial
+from ..settings_manager import SettingsDialog, settings_manager
 
 
 class MainController:
@@ -168,6 +169,10 @@ def setup_connections(self):
         self.recent_files_manager.open_file.connect(
             partial(self.open_file, mode="overwrite")
         )
+        # Settings logging
+        settings_manager.new_log_message.connect(
+            self.logger.log_message
+        )
 
     def setup_actions(self):
         """Setup actions for the main controller."""
@@ -337,6 +342,12 @@ def setup_actions(self):
             "Clear Log", self.view
         )
         actions["clear_log"].triggered.connect(self.logger.clear_log)
+        # Settings
+        actions["settings"] = QAction(
+            qta.icon("mdi6.cog"),
+            "Settings", self.view
+        )
+        actions["settings"].triggered.connect(self.open_settings)
 
         # Opening the PEtab documentation
         actions["open_documentation"] = QAction(
@@ -543,7 +554,7 @@ def _open_file(self, actionable, file_path, sep, mode):
             )
         elif actionable == "data_matrix":
             self.measurement_controller.process_data_matrix_file(
-                file_path, sep, mode
+                file_path, mode, sep
             )
 
     def open_yaml_and_load_files(self, yaml_path=None, mode="overwrite"):
@@ -745,6 +756,18 @@ def paste_from_clipboard(self):
         if controller:
             controller.paste_from_clipboard()
 
+    def open_settings(self):
+        """Opens the settings Dialogue."""
+        # retrieve all current columns from the tables
+        table_columns = {
+            "observable": self.observable_controller.get_columns(),
+            "parameter": self.parameter_controller.get_columns(),
+            "measurement": self.measurement_controller.get_columns(),
+            "condition": self.condition_controller.get_columns(),
+        }
+        settings_dialog = SettingsDialog(table_columns, self.view)
+        settings_dialog.exec()
+
     def set_docks_visible(self):
         """Handles Visibility of docks."""
         pass