From 9651714e184d1a9c410551a161fea6962c3007b8 Mon Sep 17 00:00:00 2001 From: PaulJonasJost Date: Tue, 16 Dec 2025 13:57:17 +0100 Subject: [PATCH 1/2] Using PEtab constants where found --- src/petab_gui/C.py | 189 +++++++------- src/petab_gui/controllers/default_handler.py | 9 +- .../controllers/table_controllers.py | 239 ++++++++++-------- src/petab_gui/models/pandas_table_model.py | 25 +- src/petab_gui/utils.py | 28 +- src/petab_gui/views/table_view.py | 3 +- 6 files changed, 271 insertions(+), 222 deletions(-) diff --git a/src/petab_gui/C.py b/src/petab_gui/C.py index c27860f..3b65d7c 100644 --- a/src/petab_gui/C.py +++ b/src/petab_gui/C.py @@ -1,6 +1,7 @@ """Constants for the PEtab edit GUI.""" import numpy as np +import petab.v1.C as C #: Application name APP_NAME = "PEtab-GUI" @@ -11,73 +12,79 @@ COLUMNS = { "measurement": { - "observableId": {"type": np.object_, "optional": False}, - "preequilibrationConditionId": {"type": np.object_, "optional": True}, - "simulationConditionId": {"type": np.object_, "optional": False}, - "time": {"type": np.float64, "optional": False}, - "measurement": {"type": np.float64, "optional": False}, - "observableParameters": {"type": np.object_, "optional": True}, - "noiseParameters": {"type": np.object_, "optional": True}, - "datasetId": {"type": np.object_, "optional": True}, - "replicateId": {"type": np.object_, "optional": True}, + C.OBSERVABLE_ID: {"type": np.object_, "optional": False}, + C.PREEQUILIBRATION_CONDITION_ID: { + "type": np.object_, + "optional": True, + }, + C.SIMULATION_CONDITION_ID: {"type": np.object_, "optional": False}, + C.TIME: {"type": np.float64, "optional": False}, + C.MEASUREMENT: {"type": np.float64, "optional": False}, + C.OBSERVABLE_PARAMETERS: {"type": np.object_, "optional": True}, + C.NOISE_PARAMETERS: {"type": np.object_, "optional": True}, + C.DATASET_ID: {"type": np.object_, "optional": True}, + C.REPLICATE_ID: {"type": np.object_, "optional": True}, }, "simulation": { - "observableId": {"type": np.object_, "optional": False}, - "preequilibrationConditionId": {"type": np.object_, "optional": True}, - "simulationConditionId": {"type": np.object_, "optional": False}, - "time": {"type": np.float64, "optional": False}, - "simulation": {"type": np.float64, "optional": False}, - "observableParameters": {"type": np.object_, "optional": True}, - "noiseParameters": {"type": np.object_, "optional": True}, - "datasetId": {"type": np.object_, "optional": True}, - "replicateId": {"type": np.object_, "optional": True}, + C.OBSERVABLE_ID: {"type": np.object_, "optional": False}, + C.PREEQUILIBRATION_CONDITION_ID: { + "type": np.object_, + "optional": True, + }, + C.SIMULATION_CONDITION_ID: {"type": np.object_, "optional": False}, + C.TIME: {"type": np.float64, "optional": False}, + C.SIMULATION: {"type": np.float64, "optional": False}, + C.OBSERVABLE_PARAMETERS: {"type": np.object_, "optional": True}, + C.NOISE_PARAMETERS: {"type": np.object_, "optional": True}, + C.DATASET_ID: {"type": np.object_, "optional": True}, + C.REPLICATE_ID: {"type": np.object_, "optional": True}, }, "observable": { - "observableId": {"type": np.object_, "optional": False}, - "observableName": {"type": np.object_, "optional": True}, - "observableFormula": {"type": np.object_, "optional": False}, - "observableTransformation": {"type": np.object_, "optional": True}, - "noiseFormula": {"type": np.object_, "optional": False}, - "noiseDistribution": {"type": np.object_, "optional": True}, + C.OBSERVABLE_ID: {"type": np.object_, "optional": False}, + C.OBSERVABLE_NAME: {"type": np.object_, "optional": True}, + C.OBSERVABLE_FORMULA: {"type": np.object_, "optional": False}, + C.OBSERVABLE_TRANSFORMATION: {"type": np.object_, "optional": True}, + C.NOISE_FORMULA: {"type": np.object_, "optional": False}, + C.NOISE_DISTRIBUTION: {"type": np.object_, "optional": True}, }, "parameter": { - "parameterId": {"type": np.object_, "optional": False}, - "parameterName": {"type": np.object_, "optional": True}, - "parameterScale": {"type": np.object_, "optional": False}, - "lowerBound": {"type": np.float64, "optional": False}, - "upperBound": {"type": np.float64, "optional": False}, - "nominalValue": {"type": np.float64, "optional": False}, - "estimate": {"type": np.object_, "optional": False}, - "initializationPriorType": {"type": np.object_, "optional": True}, - "initializationPriorParameters": { + C.PARAMETER_ID: {"type": np.object_, "optional": False}, + C.PARAMETER_NAME: {"type": np.object_, "optional": True}, + C.PARAMETER_SCALE: {"type": np.object_, "optional": False}, + C.LOWER_BOUND: {"type": np.float64, "optional": False}, + C.UPPER_BOUND: {"type": np.float64, "optional": False}, + C.NOMINAL_VALUE: {"type": np.float64, "optional": False}, + C.ESTIMATE: {"type": np.object_, "optional": False}, + C.INITIALIZATION_PRIOR_TYPE: {"type": np.object_, "optional": True}, + C.INITIALIZATION_PRIOR_PARAMETERS: { "type": np.object_, "optional": True, }, - "objectivePriorType": {"type": np.object_, "optional": True}, - "objectivePriorParameters": {"type": np.object_, "optional": True}, + C.OBJECTIVE_PRIOR_TYPE: {"type": np.object_, "optional": True}, + C.OBJECTIVE_PRIOR_PARAMETERS: {"type": np.object_, "optional": True}, }, "condition": { - "conditionId": {"type": np.object_, "optional": False}, - "conditionName": {"type": np.object_, "optional": False}, + C.CONDITION_ID: {"type": np.object_, "optional": False}, + C.CONDITION_NAME: {"type": np.object_, "optional": False}, }, "visualization": { - "plotId": {"type": np.object_, "optional": False}, - "plotName": {"type": np.object_, "optional": True}, - "plotTypeSimulation": { + C.PLOT_ID: {"type": np.object_, "optional": False}, + C.PLOT_NAME: {"type": np.object_, "optional": True}, + C.PLOT_TYPE_SIMULATION: { "type": np.object_, "optional": True, }, - "plotTypeData": {"type": np.object_, "optional": True}, - "datasetId": {"type": np.object_, "optional": True}, - "xValues": {"type": np.object_, "optional": True}, - "xOffset": {"type": np.float64, "optional": True}, - "xLabel": {"type": np.object_, "optional": True}, - "xScale": {"type": np.object_, "optional": True}, - "yValues": {"type": np.object_, "optional": True}, - "yOffset": {"type": np.float64, "optional": True}, - "yLabel": {"type": np.object_, "optional": True}, - "yScale": {"type": np.object_, "optional": True}, - "legendEntry": {"type": np.object_, "optional": True}, + C.PLOT_TYPE_DATA: {"type": np.object_, "optional": True}, + C.DATASET_ID: {"type": np.object_, "optional": True}, + C.X_VALUES: {"type": np.object_, "optional": True}, + C.X_OFFSET: {"type": np.float64, "optional": True}, + C.X_LABEL: {"type": np.object_, "optional": True}, + C.X_SCALE: {"type": np.object_, "optional": True}, + C.Y_VALUES: {"type": np.object_, "optional": True}, + C.Y_OFFSET: {"type": np.float64, "optional": True}, + C.Y_LABEL: {"type": np.object_, "optional": True}, + C.Y_SCALE: {"type": np.object_, "optional": True}, + C.LEGEND_ENTRY: {"type": np.object_, "optional": True}, }, } @@ -126,36 +133,36 @@ # 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], + C.OBSERVABLE_ID: STRATEGIES_DEFAULT, + C.OBSERVABLE_NAME: STRATEGIES_DEFAULT, + C.OBSERVABLE_FORMULA: STRATEGIES_DEFAULT, + C.OBSERVABLE_TRANSFORMATION: [USE_DEFAULT, NO_DEFAULT, MODE], + C.NOISE_FORMULA: [COPY_FROM, USE_DEFAULT, NO_DEFAULT, MODE], + C.NOISE_DISTRIBUTION: [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, SBML_LOOK], - "estimate": [USE_DEFAULT, NO_DEFAULT, MODE], + C.PARAMETER_ID: STRATEGIES_DEFAULT, + C.PARAMETER_NAME: STRATEGIES_DEFAULT, + C.PARAMETER_SCALE: [USE_DEFAULT, NO_DEFAULT, MODE], + C.LOWER_BOUND: [MIN_COLUMN, MAX_COLUMN, USE_DEFAULT, NO_DEFAULT, MODE], + C.UPPER_BOUND: [MAX_COLUMN, MAX_COLUMN, USE_DEFAULT, NO_DEFAULT, MODE], + C.NOMINAL_VALUE: [USE_DEFAULT, NO_DEFAULT, SBML_LOOK], + C.ESTIMATE: [USE_DEFAULT, NO_DEFAULT, MODE], } ALLOWED_STRATEGIES_COND = { - "conditionId": STRATEGIES_DEFAULT, - "conditionName": STRATEGIES_DEFAULT, + C.CONDITION_ID: STRATEGIES_DEFAULT, + C.CONDITION_NAME: 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], + C.OBSERVABLE_ID: STRATEGIES_DEFAULT, + C.PREEQUILIBRATION_CONDITION_ID: STRATEGIES_DEFAULT_EXT, + C.SIMULATION_CONDITION_ID: STRATEGIES_DEFAULT_EXT, + C.TIME: [NO_DEFAULT, USE_DEFAULT, MODE], + C.MEASUREMENT: [NO_DEFAULT, USE_DEFAULT, MODE], + C.OBSERVABLE_PARAMETERS: STRATEGIES_DEFAULT_EXT, + C.NOISE_PARAMETERS: STRATEGIES_DEFAULT_EXT, + C.DATASET_ID: [COPY_FROM, USE_DEFAULT, NO_DEFAULT, MODE], + C.REPLICATE_ID: [COPY_FROM, USE_DEFAULT, NO_DEFAULT, MODE], } ALLOWED_STRATEGIES = { "observable": ALLOWED_STRATEGIES_OBS, @@ -164,34 +171,34 @@ "measurement": ALLOWED_STRATEGIES_MEAS, } DEFAULT_OBS_CONFIG = { - "observableId": { + C.OBSERVABLE_ID: { "strategy": COPY_FROM, - SOURCE_COLUMN: "observableFormula", + SOURCE_COLUMN: C.OBSERVABLE_FORMULA, DEFAULT_VALUE: "new_observable", }, - "observableName": {"strategy": COPY_FROM, SOURCE_COLUMN: "observableId"}, - "noiseFormula": {"strategy": USE_DEFAULT, DEFAULT_VALUE: 1}, - "observableTransformation": { + C.OBSERVABLE_NAME: {"strategy": COPY_FROM, SOURCE_COLUMN: C.OBSERVABLE_ID}, + C.NOISE_FORMULA: {"strategy": USE_DEFAULT, DEFAULT_VALUE: 1}, + C.OBSERVABLE_TRANSFORMATION: { "strategy": USE_DEFAULT, - DEFAULT_VALUE: "lin", + DEFAULT_VALUE: C.LIN, }, - "noiseDistribution": {"strategy": USE_DEFAULT, DEFAULT_VALUE: "normal"}, + C.NOISE_DISTRIBUTION: {"strategy": USE_DEFAULT, DEFAULT_VALUE: C.NORMAL}, } DEFAULT_PAR_CONFIG = { - "parameterName": { + C.PARAMETER_NAME: { "strategy": COPY_FROM, - SOURCE_COLUMN: "parameterId", + SOURCE_COLUMN: C.PARAMETER_ID, 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}, - "nominalValue": {"strategy": SBML_LOOK}, + C.PARAMETER_SCALE: {"strategy": USE_DEFAULT, DEFAULT_VALUE: C.LOG10}, + C.LOWER_BOUND: {"strategy": MIN_COLUMN}, + C.UPPER_BOUND: {"strategy": MAX_COLUMN}, + C.ESTIMATE: {"strategy": USE_DEFAULT, DEFAULT_VALUE: 1}, + C.NOMINAL_VALUE: {"strategy": SBML_LOOK}, } DEFAULT_COND_CONFIG = { - "conditionId": {"strategy": USE_DEFAULT, DEFAULT_VALUE: "new_condition"}, - "conditionName": {"strategy": COPY_FROM, SOURCE_COLUMN: "conditionId"}, + C.CONDITION_ID: {"strategy": USE_DEFAULT, DEFAULT_VALUE: "new_condition"}, + C.CONDITION_NAME: {"strategy": COPY_FROM, SOURCE_COLUMN: C.CONDITION_ID}, } DEFAULT_MEAS_CONFIG = {} DEFAULT_CONFIGS = { diff --git a/src/petab_gui/controllers/default_handler.py b/src/petab_gui/controllers/default_handler.py index 99428dc..cd476b6 100644 --- a/src/petab_gui/controllers/default_handler.py +++ b/src/petab_gui/controllers/default_handler.py @@ -5,6 +5,7 @@ import numpy as np import pandas as pd +import petab.v1 as petab from ..C import ( COPY_FROM, @@ -94,9 +95,9 @@ def _min_column(self, column_name, par_scale=None): if column_name not in self.model: return "" column_data = self.model[column_name].replace("", np.nan).dropna() - if column_name in ["upperBound", "lowerBound"]: + if column_name in [petab.C.UPPER_BOUND, petab.C.LOWER_BOUND]: column_data = column_data.loc[ - self.model["parameterScale"] == par_scale + self.model[petab.C.PARAMETER_SCALE] == par_scale ] if not column_data.empty: return column_data.min() @@ -106,9 +107,9 @@ def _max_column(self, column_name, par_scale=None): if column_name not in self.model: return "" column_data = self.model[column_name].replace("", np.nan).dropna() - if column_name in ["upperBound", "lowerBound"]: + if column_name in [petab.C.UPPER_BOUND, petab.C.LOWER_BOUND]: column_data = column_data.loc[ - self.model["parameterScale"] == par_scale + self.model[petab.C.PARAMETER_SCALE] == par_scale ] if not column_data.empty: return column_data.max() diff --git a/src/petab_gui/controllers/table_controllers.py b/src/petab_gui/controllers/table_controllers.py index 7327a8a..fa419d4 100644 --- a/src/petab_gui/controllers/table_controllers.py +++ b/src/petab_gui/controllers/table_controllers.py @@ -667,18 +667,18 @@ def copy_noise_parameters( """ measurement_df = self.model.measurement._data_frame matching_rows = measurement_df[ - measurement_df["observableId"] == observable_id + measurement_df[petab.C.OBSERVABLE_ID] == observable_id ] if matching_rows.empty: return "" if not condition_id: - return matching_rows["noiseParameters"].iloc[0] + return matching_rows[petab.C.NOISE_PARAMETERS].iloc[0] preferred_row = matching_rows[ - matching_rows["simulationConditionId"] == condition_id + matching_rows[petab.C.SIMULATION_CONDITION_ID] == condition_id ] if not preferred_row.empty: - return preferred_row["noiseParameters"].iloc[0] - return matching_rows["noiseParameters"].iloc[0] + return preferred_row[petab.C.NOISE_PARAMETERS].iloc[0] + return matching_rows[petab.C.NOISE_PARAMETERS].iloc[0] def upload_data_matrix(self): """Upload a data matrix to the measurement table. @@ -713,13 +713,15 @@ def process_data_matrix_file(self, file_name, mode, separator=None): dose_col_sel: str | None = None time_col = self._detect_time_column(data_matrix) if time_col: - df_proc = data_matrix.rename(columns={time_col: "time"}) + df_proc = data_matrix.rename(columns={time_col: petab.C.TIME}) cond_dialog = ConditionInputDialog() if cond_dialog.exec(): conditions = cond_dialog.get_inputs() - condition_id = conditions.get("simulationConditionId", "") + condition_id = conditions.get( + petab.C.SIMULATION_CONDITION_ID, "" + ) preeq_id = conditions.get( - "preequilibrationConditionId", "" + petab.C.PREEQUILIBRATION_CONDITION_ID, "" ) else: return @@ -739,10 +741,10 @@ def process_data_matrix_file(self, file_name, mode, separator=None): isinstance(time_choice, str) and time_choice.strip().lower() == "inf" ): - df_proc["time"] = "inf" + df_proc[petab.C.TIME] = "inf" else: try: - df_proc["time"] = float(time_choice) + df_proc[petab.C.TIME] = float(time_choice) except Exception: self.logger.log_message( f"Invalid time value: {time_choice}", color="red" @@ -937,7 +939,7 @@ def populate_tables_from_data_matrix( for cid in sorted(set(condition_ids)): self.model.relevant_id_changed.emit(cid, "", "condition") for col in data_matrix.columns: - if col == "time": + if col == petab.C.TIME: continue if dose_col and col == dose_col: continue @@ -952,7 +954,7 @@ def populate_tables_from_data_matrix( if preeq_id: self.model.relevant_id_changed.emit(preeq_id, "", "condition") self.add_measurement_rows( - data_matrix[["time", observable_id]], + data_matrix[[petab.C.TIME, observable_id]], observable_id, condition_id, preeq_id, @@ -985,11 +987,11 @@ def add_measurement_rows( self.model.fill_row( i_row + current_rows, data={ - "observableId": observable_id, - "time": row["time"], - "measurement": row[observable_id], - "simulationConditionId": cid, - "preequilibrationConditionId": preeq_id, + petab.C.OBSERVABLE_ID: observable_id, + petab.C.TIME: row[petab.C.TIME], + petab.C.MEASUREMENT: row[observable_id], + petab.C.SIMULATION_CONDITION_ID: cid, + petab.C.PREEQUILIBRATION_CONDITION_ID: preeq_id, }, ) bottom, right = (x - 1 for x in self.model.get_df().shape) @@ -1004,52 +1006,59 @@ def setup_completers(self): """Set completers for the measurement table.""" table_view = self.view.table_view # observableId - observableId_index = self.model.return_column_index("observableId") + observableId_index = self.model.return_column_index( + petab.C.OBSERVABLE_ID + ) if observableId_index > -1: - self.completers["observableId"] = ColumnSuggestionDelegate( - self.mother_controller.model.observable, "observableId" + self.completers[petab.C.OBSERVABLE_ID] = ColumnSuggestionDelegate( + self.mother_controller.model.observable, petab.C.OBSERVABLE_ID ) table_view.setItemDelegateForColumn( - observableId_index, self.completers["observableId"] + observableId_index, self.completers[petab.C.OBSERVABLE_ID] ) # preequilibrationConditionId preequilibrationConditionId_index = self.model.return_column_index( - "preequilibrationConditionId" + petab.C.PREEQUILIBRATION_CONDITION_ID ) if preequilibrationConditionId_index > -1: - self.completers["preequilibrationConditionId"] = ( + self.completers[petab.C.PREEQUILIBRATION_CONDITION_ID] = ( ColumnSuggestionDelegate( - self.mother_controller.model.condition, "conditionId" + self.mother_controller.model.condition, + petab.C.CONDITION_ID, ) ) table_view.setItemDelegateForColumn( preequilibrationConditionId_index, - self.completers["preequilibrationConditionId"], + self.completers[petab.C.PREEQUILIBRATION_CONDITION_ID], ) # simulationConditionId simulationConditionId_index = self.model.return_column_index( - "simulationConditionId" + petab.C.SIMULATION_CONDITION_ID ) if simulationConditionId_index > -1: - self.completers["simulationConditionId"] = ( + self.completers[petab.C.SIMULATION_CONDITION_ID] = ( ColumnSuggestionDelegate( - self.mother_controller.model.condition, "conditionId" + self.mother_controller.model.condition, + petab.C.CONDITION_ID, ) ) table_view.setItemDelegateForColumn( simulationConditionId_index, - self.completers["simulationConditionId"], + self.completers[petab.C.SIMULATION_CONDITION_ID], ) # noiseParameters noiseParameters_index = self.model.return_column_index( - "noiseParameters" + petab.C.NOISE_PARAMETERS ) if noiseParameters_index > -1: - self.completers["noiseParameters"] = SingleSuggestionDelegate( - self.model, "observableId", afix="sd_" + self.completers[petab.C.NOISE_PARAMETERS] = ( + SingleSuggestionDelegate( + self.model, petab.C.OBSERVABLE_ID, afix="sd_" + ) ) table_view.setItemDelegateForColumn( - noiseParameters_index, self.completers["noiseParameters"] + noiseParameters_index, + self.completers[petab.C.NOISE_PARAMETERS], ) @@ -1095,7 +1104,7 @@ def maybe_rename_condition(self, new_id, old_id): If so, emits a signal to rename the conditions in the measurement_df. """ df = self.mother_controller.measurement_controller.model.get_df() - if old_id not in df["simulationConditionId"].values: + if old_id not in df[petab.C.SIMULATION_CONDITION_ID].values: return reply = QMessageBox.question( self.view, @@ -1121,7 +1130,7 @@ def maybe_add_condition(self, condition_id, old_id=None): self.model.insertRows(position=None, rows=1) self.model.fill_row( self.model.get_df().shape[0] - 1, - data={"conditionId": condition_id}, + data={petab.C.CONDITION_ID: condition_id}, ) self.model.cell_needs_validation.emit( self.model.get_df().shape[0] - 1, 0 @@ -1136,16 +1145,18 @@ def setup_completers(self): """Set completers for the condition table.""" table_view = self.view.table_view # conditionName - conditionName_index = self.model.return_column_index("conditionName") + conditionName_index = self.model.return_column_index( + petab.C.CONDITION_NAME + ) if conditionName_index > -1: - self.completers["conditionName"] = SingleSuggestionDelegate( - self.model, "conditionId" + self.completers[petab.C.CONDITION_NAME] = SingleSuggestionDelegate( + self.model, petab.C.CONDITION_ID ) table_view.setItemDelegateForColumn( - conditionName_index, self.completers["conditionName"] + conditionName_index, self.completers[petab.C.CONDITION_NAME] ) for column in self.model.get_df().columns: - if column in ["conditionId", "conditionName"]: + if column in [petab.C.CONDITION_ID, petab.C.CONDITION_NAME]: continue column_index = self.model.return_column_index(column) if column_index > -1: @@ -1170,45 +1181,50 @@ def setup_completers(self): """Set completers for the observable table.""" table_view = self.view.table_view # observableName - observableName_index = self.model.return_column_index("observableName") + observableName_index = self.model.return_column_index( + petab.C.OBSERVABLE_NAME + ) if observableName_index > -1: - self.completers["observableName"] = SingleSuggestionDelegate( - self.model, "observableId" + self.completers[petab.C.OBSERVABLE_NAME] = ( + SingleSuggestionDelegate(self.model, petab.C.OBSERVABLE_ID) ) table_view.setItemDelegateForColumn( - observableName_index, self.completers["observableName"] + observableName_index, self.completers[petab.C.OBSERVABLE_NAME] ) # observableTransformation observableTransformation_index = self.model.return_column_index( - "observableTransformation" + petab.C.OBSERVABLE_TRANSFORMATION ) if observableTransformation_index > -1: - self.completers["observableTransformation"] = ComboBoxDelegate( - ["lin", "log", "log10"] + self.completers[petab.C.OBSERVABLE_TRANSFORMATION] = ( + ComboBoxDelegate([petab.C.LIN, petab.C.LOG, petab.C.LOG10]) ) table_view.setItemDelegateForColumn( observableTransformation_index, - self.completers["observableTransformation"], + self.completers[petab.C.OBSERVABLE_TRANSFORMATION], ) # noiseFormula - noiseFormula_index = self.model.return_column_index("noiseFormula") + noiseFormula_index = self.model.return_column_index( + petab.C.NOISE_FORMULA + ) if noiseFormula_index > -1: - self.completers["noiseFormula"] = SingleSuggestionDelegate( - self.model, "observableId", afix="noiseParameter1_" + self.completers[petab.C.NOISE_FORMULA] = SingleSuggestionDelegate( + self.model, petab.C.OBSERVABLE_ID, afix="noiseParameter1_" ) table_view.setItemDelegateForColumn( - noiseFormula_index, self.completers["noiseFormula"] + noiseFormula_index, self.completers[petab.C.NOISE_FORMULA] ) # noiseDistribution noiseDistribution_index = self.model.return_column_index( - "noiseDistribution" + petab.C.NOISE_DISTRIBUTION ) if noiseDistribution_index > -1: - self.completers["noiseDistribution"] = ComboBoxDelegate( - ["normal", "laplace"] + self.completers[petab.C.NOISE_DISTRIBUTION] = ComboBoxDelegate( + [petab.C.NORMAL, petab.C.LAPLACE] ) table_view.setItemDelegateForColumn( - noiseDistribution_index, self.completers["noiseDistribution"] + noiseDistribution_index, + self.completers[petab.C.NOISE_DISTRIBUTION], ) def setup_connections_specific(self): @@ -1238,7 +1254,7 @@ def maybe_rename_observable(self, new_id, old_id): If so, emits a signal to rename the observables in the measurement_df. """ df = self.mother_controller.measurement_controller.model.get_df() - if old_id not in df["observableId"].values: + if old_id not in df[petab.C.OBSERVABLE_ID].values: return reply = QMessageBox.question( self.view, @@ -1268,7 +1284,7 @@ def maybe_add_observable(self, observable_id, old_id=None): self.model.insertRows(position=None, rows=1) self.model.fill_row( self.model.get_df().shape[0] - 1, - data={"observableId": observable_id}, + data={petab.C.OBSERVABLE_ID: observable_id}, ) self.model.cell_needs_validation.emit( self.model.get_df().shape[0] - 1, 0 @@ -1300,57 +1316,65 @@ def setup_completers(self): """Set completers for the parameter table.""" table_view = self.view.table_view # parameterName - parameterName_index = self.model.return_column_index("parameterName") + parameterName_index = self.model.return_column_index( + petab.C.PARAMETER_NAME + ) if parameterName_index > -1: - self.completers["parameterName"] = SingleSuggestionDelegate( - self.model, "parameterId" + self.completers[petab.C.PARAMETER_NAME] = SingleSuggestionDelegate( + self.model, petab.C.PARAMETER_ID ) table_view.setItemDelegateForColumn( - parameterName_index, self.completers["parameterName"] + parameterName_index, self.completers[petab.C.PARAMETER_NAME] ) # parameterScale - parameterScale_index = self.model.return_column_index("parameterScale") + parameterScale_index = self.model.return_column_index( + petab.C.PARAMETER_SCALE + ) if parameterScale_index > -1: - self.completers["parameterScale"] = ComboBoxDelegate( - ["lin", "log", "log10"] + self.completers[petab.C.PARAMETER_SCALE] = ComboBoxDelegate( + [petab.C.LIN, petab.C.LOG, petab.C.LOG10] ) table_view.setItemDelegateForColumn( - parameterScale_index, self.completers["parameterScale"] + parameterScale_index, self.completers[petab.C.PARAMETER_SCALE] ) # lowerBound - lowerBound_index = self.model.return_column_index("lowerBound") + lowerBound_index = self.model.return_column_index(petab.C.LOWER_BOUND) if lowerBound_index > -1: - self.completers["lowerBound"] = ColumnSuggestionDelegate( - self.model, "lowerBound", QCompleter.PopupCompletion + self.completers[petab.C.LOWER_BOUND] = ColumnSuggestionDelegate( + self.model, petab.C.LOWER_BOUND, QCompleter.PopupCompletion ) table_view.setItemDelegateForColumn( - lowerBound_index, self.completers["lowerBound"] + lowerBound_index, self.completers[petab.C.LOWER_BOUND] ) # upperBound - upperBound_index = self.model.return_column_index("upperBound") + upperBound_index = self.model.return_column_index(petab.C.UPPER_BOUND) if upperBound_index > -1: - self.completers["upperBound"] = ColumnSuggestionDelegate( - self.model, "upperBound", QCompleter.PopupCompletion + self.completers[petab.C.UPPER_BOUND] = ColumnSuggestionDelegate( + self.model, petab.C.UPPER_BOUND, QCompleter.PopupCompletion ) table_view.setItemDelegateForColumn( - upperBound_index, self.completers["upperBound"] + upperBound_index, self.completers[petab.C.UPPER_BOUND] ) # estimate - estimate_index = self.model.return_column_index("estimate") + estimate_index = self.model.return_column_index(petab.C.ESTIMATE) if estimate_index > -1: - self.completers["estimate"] = ComboBoxDelegate(["1", "0"]) + self.completers[petab.C.ESTIMATE] = ComboBoxDelegate(["1", "0"]) table_view.setItemDelegateForColumn( - estimate_index, self.completers["estimate"] + estimate_index, self.completers[petab.C.ESTIMATE] ) # parameterId: retrieved from the sbml model - parameterId_index = self.model.return_column_index("parameterId") + parameterId_index = self.model.return_column_index( + petab.C.PARAMETER_ID + ) sbml_model = self.mother_controller.model.sbml if parameterId_index > -1: - self.completers["parameterId"] = ParameterIdSuggestionDelegate( - par_model=self.model, sbml_model=sbml_model + self.completers[petab.C.PARAMETER_ID] = ( + ParameterIdSuggestionDelegate( + par_model=self.model, sbml_model=sbml_model + ) ) table_view.setItemDelegateForColumn( - parameterId_index, self.completers["parameterId"] + parameterId_index, self.completers[petab.C.PARAMETER_ID] ) @linter_wrapper(additional_error_check=True) @@ -1431,56 +1455,61 @@ def setup_completers(self): """Set completers for the visualization table.""" table_view = self.view.table_view # plotTypeSimulation - index = self.model.return_column_index("plotTypeSimulation") + index = self.model.return_column_index(petab.C.PLOT_TYPE_SIMULATION) if index and index > -1: - self.completers["plotTypeSimulation"] = ComboBoxDelegate( - ["LinePlot", "BarPlot", "ScatterPlot"] + self.completers[petab.C.PLOT_TYPE_SIMULATION] = ComboBoxDelegate( + [petab.C.LINE_PLOT, petab.C.BAR_PLOT, petab.C.SCATTER_PLOT] ) table_view.setItemDelegateForColumn( - index, self.completers["plotTypeSimulation"] + index, self.completers[petab.C.PLOT_TYPE_SIMULATION] ) # plotTypeData - index = self.model.return_column_index("plotTypeData") + index = self.model.return_column_index(petab.C.PLOT_TYPE_DATA) if index and index > -1: - self.completers["plotTypeData"] = ComboBoxDelegate( - ["MeanAndSD", "MeanAndSEM", "replicate", "provided"] + self.completers[petab.C.PLOT_TYPE_DATA] = ComboBoxDelegate( + [ + petab.C.MEAN_AND_SD, + petab.C.MEAN_AND_SEM, + petab.C.REPLICATE, + petab.C.PROVIDED, + ] ) table_view.setItemDelegateForColumn( - index, self.completers["plotTypeData"] + index, self.completers[petab.C.PLOT_TYPE_DATA] ) # datasetId - index = self.model.return_column_index("datasetId") + index = self.model.return_column_index(petab.C.DATASET_ID) if index and index > -1: - self.completers["datasetId"] = ColumnSuggestionDelegate( - self.mother_controller.model.measurement, "datasetId" + self.completers[petab.C.DATASET_ID] = ColumnSuggestionDelegate( + self.mother_controller.model.measurement, petab.C.DATASET_ID ) table_view.setItemDelegateForColumn( - index, self.completers["datasetId"] + index, self.completers[petab.C.DATASET_ID] ) # yValues - index = self.model.return_column_index("yValues") + index = self.model.return_column_index(petab.C.Y_VALUES) if index and index > -1: - self.completers["yValues"] = ColumnSuggestionDelegate( - self.mother_controller.model.observable, "observableId" + self.completers[petab.C.Y_VALUES] = ColumnSuggestionDelegate( + self.mother_controller.model.observable, petab.C.OBSERVABLE_ID ) table_view.setItemDelegateForColumn( - index, self.completers["yValues"] + index, self.completers[petab.C.Y_VALUES] ) # xScale - index = self.model.return_column_index("xScale") + index = self.model.return_column_index(petab.C.X_SCALE) if index and index > -1: - self.completers["xScale"] = ComboBoxDelegate( - ["lin", "log", "log10", "order"] + self.completers[petab.C.X_SCALE] = ComboBoxDelegate( + [petab.C.LIN, petab.C.LOG, petab.C.LOG10, "order"] ) table_view.setItemDelegateForColumn( - index, self.completers["xScale"] + index, self.completers[petab.C.X_SCALE] ) # yScale - index = self.model.return_column_index("yScale") + index = self.model.return_column_index(petab.C.Y_SCALE) if index and index > -1: - self.completers["yScale"] = ComboBoxDelegate( - ["lin", "log", "log10", "order"] + self.completers[petab.C.Y_SCALE] = ComboBoxDelegate( + [petab.C.LIN, petab.C.LOG, petab.C.LOG10, "order"] ) table_view.setItemDelegateForColumn( - index, self.completers["yScale"] + index, self.completers[petab.C.Y_SCALE] ) diff --git a/src/petab_gui/models/pandas_table_model.py b/src/petab_gui/models/pandas_table_model.py index 16b86e7..b7764cc 100644 --- a/src/petab_gui/models/pandas_table_model.py +++ b/src/petab_gui/models/pandas_table_model.py @@ -1,5 +1,6 @@ from typing import Any +import petab.v1 as petab from PySide6.QtCore import ( QAbstractTableModel, QMimeData, @@ -391,7 +392,7 @@ def _set_data_single(self, index, value): return False # Special ID emitters - if column_name == "observableId": + if column_name == petab.C.OBSERVABLE_ID: if fill_with_defaults: self.get_default_values(index, {column_name: value}) self.relevant_id_changed.emit(value, old_value, "observable") @@ -401,9 +402,9 @@ def _set_data_single(self, index, value): return True if column_name in [ - "conditionId", - "simulationConditionId", - "preequilibrationConditionId", + petab.C.CONDITION_ID, + petab.C.SIMULATION_CONDITION_ID, + petab.C.PREEQUILIBRATION_CONDITION_ID, ]: if fill_with_defaults: self.get_default_values(index, {column_name: value}) @@ -993,9 +994,9 @@ def get_default_values(self, index, changed: dict | None = None): columns_with_index = [df.index.name] if df.index.name else [] columns_with_index += list(df.columns) # ensure parameterScale is before lowerBound and upperBound (potential) - if "parameterScale" in columns_with_index: - columns_with_index.remove("parameterScale") - columns_with_index.insert(1, "parameterScale") + if petab.C.PARAMETER_SCALE in columns_with_index: + columns_with_index.remove(petab.C.PARAMETER_SCALE) + columns_with_index.insert(1, petab.C.PARAMETER_SCALE) for colname in columns_with_index: if changed and colname in changed: @@ -1010,11 +1011,11 @@ def get_default_values(self, index, changed: dict | None = None): ) and bool(default_value): rename_needed = True new_index = default_value - elif colname in ["upperBound", "lowerBound"]: + elif colname in [petab.C.UPPER_BOUND, petab.C.LOWER_BOUND]: par_scale = ( - changes[(row_key, "parameterScale")][1] - if (row_key, "parameterScale") in changes - else changed["parameterScale"] + changes[(row_key, petab.C.PARAMETER_SCALE)][1] + if (row_key, petab.C.PARAMETER_SCALE) in changes + else changed[petab.C.PARAMETER_SCALE] ) default_value = self.default_handler.get_default( colname, row_key, par_scale @@ -1161,7 +1162,7 @@ def __init__(self, data_frame, parent=None): table_type="condition", parent=parent, ) - self._allowed_columns.pop("conditionId") + self._allowed_columns.pop(petab.C.CONDITION_ID) class PandasTableFilterProxy(QSortFilterProxyModel): diff --git a/src/petab_gui/utils.py b/src/petab_gui/utils.py index 2133fd0..24bb48e 100644 --- a/src/petab_gui/utils.py +++ b/src/petab_gui/utils.py @@ -7,6 +7,7 @@ import antimony import numpy as np import pandas as pd +import petab.v1 as petab import qtawesome as qta from matplotlib.backends.backend_qt5agg import ( FigureCanvasQTAgg as FigureCanvas, @@ -253,11 +254,11 @@ def create_empty_dataframe(column_dict: dict, table_type: str): df = pd.DataFrame(columns=columns).astype(dtypes) # set potential index columns if table_type == "observable": - df.set_index("observableId", inplace=True) + df.set_index(petab.C.OBSERVABLE_ID, inplace=True) elif table_type == "parameter": - df.set_index("parameterId", inplace=True) + df.set_index(petab.C.PARAMETER_ID, inplace=True) elif table_type == "condition": - df.set_index("conditionId", inplace=True) + df.set_index(petab.C.CONDITION_ID, inplace=True) return df @@ -408,17 +409,26 @@ def process_file(filepath, logger): return None, None # Case 3.2: Identify the table type based on header content - if {"observableId", "measurement", "time"}.issubset(header): + if {petab.C.OBSERVABLE_ID, petab.C.MEASUREMENT, petab.C.TIME}.issubset( + header + ): return "measurement", separator - if {"observableId", "simulation", "time"}.issubset(header): + if {petab.C.OBSERVABLE_ID, petab.C.SIMULATION, petab.C.TIME}.issubset( + header + ): return "simulation", separator - if {"observableId", "observableFormula"}.issubset(header): + if {petab.C.OBSERVABLE_ID, petab.C.OBSERVABLE_FORMULA}.issubset( + header + ): return "observable", separator - if "parameterId" in header: + if petab.C.PARAMETER_ID in header: return "parameter", separator - if "conditionId" in header or "\ufeffconditionId" in header: + if ( + petab.C.CONDITION_ID in header + or f"\ufeff{petab.C.CONDITION_ID}" in header + ): return "condition", separator - if "plotId" in header: + if petab.C.PLOT_ID in header: return "visualization", separator logger.log_message( f"Unrecognized table type for file: {filepath}. Uploading as " diff --git a/src/petab_gui/views/table_view.py b/src/petab_gui/views/table_view.py index d89452f..af83372 100644 --- a/src/petab_gui/views/table_view.py +++ b/src/petab_gui/views/table_view.py @@ -1,3 +1,4 @@ +import petab.v1 as petab from PySide6.QtCore import QPropertyAnimation, QRect, Qt from PySide6.QtGui import QColor, QGuiApplication from PySide6.QtWidgets import ( @@ -263,7 +264,7 @@ def createEditor(self, parent, option, index): # substract the current parameter ids except for the current row row = index.row() selected_parameter_id = self.par_model.get_value_from_column( - "parameterId", row + petab.C.PARAMETER_ID, row ) current_parameter_ids = self.par_model.get_df().index.tolist() if selected_parameter_id in current_parameter_ids: From c3bab9518638cd6febec360556703ce08706c261 Mon Sep 17 00:00:00 2001 From: PaulJonasJost Date: Fri, 19 Dec 2025 11:42:06 +0100 Subject: [PATCH 2/2] Amibguous imprt in C.py of constants --- src/petab_gui/C.py | 226 +++++++++++++++++++++++++++------------------ 1 file changed, 134 insertions(+), 92 deletions(-) diff --git a/src/petab_gui/C.py b/src/petab_gui/C.py index 3b65d7c..b230e37 100644 --- a/src/petab_gui/C.py +++ b/src/petab_gui/C.py @@ -1,7 +1,7 @@ """Constants for the PEtab edit GUI.""" import numpy as np -import petab.v1.C as C +import petab.v1.C as PETAB_C #: Application name APP_NAME = "PEtab-GUI" @@ -12,79 +12,94 @@ COLUMNS = { "measurement": { - C.OBSERVABLE_ID: {"type": np.object_, "optional": False}, - C.PREEQUILIBRATION_CONDITION_ID: { + PETAB_C.OBSERVABLE_ID: {"type": np.object_, "optional": False}, + PETAB_C.PREEQUILIBRATION_CONDITION_ID: { "type": np.object_, "optional": True, }, - C.SIMULATION_CONDITION_ID: {"type": np.object_, "optional": False}, - C.TIME: {"type": np.float64, "optional": False}, - C.MEASUREMENT: {"type": np.float64, "optional": False}, - C.OBSERVABLE_PARAMETERS: {"type": np.object_, "optional": True}, - C.NOISE_PARAMETERS: {"type": np.object_, "optional": True}, - C.DATASET_ID: {"type": np.object_, "optional": True}, - C.REPLICATE_ID: {"type": np.object_, "optional": True}, + PETAB_C.SIMULATION_CONDITION_ID: { + "type": np.object_, + "optional": False, + }, + PETAB_C.TIME: {"type": np.float64, "optional": False}, + PETAB_C.MEASUREMENT: {"type": np.float64, "optional": False}, + PETAB_C.OBSERVABLE_PARAMETERS: {"type": np.object_, "optional": True}, + PETAB_C.NOISE_PARAMETERS: {"type": np.object_, "optional": True}, + PETAB_C.DATASET_ID: {"type": np.object_, "optional": True}, + PETAB_C.REPLICATE_ID: {"type": np.object_, "optional": True}, }, "simulation": { - C.OBSERVABLE_ID: {"type": np.object_, "optional": False}, - C.PREEQUILIBRATION_CONDITION_ID: { + PETAB_C.OBSERVABLE_ID: {"type": np.object_, "optional": False}, + PETAB_C.PREEQUILIBRATION_CONDITION_ID: { "type": np.object_, "optional": True, }, - C.SIMULATION_CONDITION_ID: {"type": np.object_, "optional": False}, - C.TIME: {"type": np.float64, "optional": False}, - C.SIMULATION: {"type": np.float64, "optional": False}, - C.OBSERVABLE_PARAMETERS: {"type": np.object_, "optional": True}, - C.NOISE_PARAMETERS: {"type": np.object_, "optional": True}, - C.DATASET_ID: {"type": np.object_, "optional": True}, - C.REPLICATE_ID: {"type": np.object_, "optional": True}, + PETAB_C.SIMULATION_CONDITION_ID: { + "type": np.object_, + "optional": False, + }, + PETAB_C.TIME: {"type": np.float64, "optional": False}, + PETAB_C.SIMULATION: {"type": np.float64, "optional": False}, + PETAB_C.OBSERVABLE_PARAMETERS: {"type": np.object_, "optional": True}, + PETAB_C.NOISE_PARAMETERS: {"type": np.object_, "optional": True}, + PETAB_C.DATASET_ID: {"type": np.object_, "optional": True}, + PETAB_C.REPLICATE_ID: {"type": np.object_, "optional": True}, }, "observable": { - C.OBSERVABLE_ID: {"type": np.object_, "optional": False}, - C.OBSERVABLE_NAME: {"type": np.object_, "optional": True}, - C.OBSERVABLE_FORMULA: {"type": np.object_, "optional": False}, - C.OBSERVABLE_TRANSFORMATION: {"type": np.object_, "optional": True}, - C.NOISE_FORMULA: {"type": np.object_, "optional": False}, - C.NOISE_DISTRIBUTION: {"type": np.object_, "optional": True}, + PETAB_C.OBSERVABLE_ID: {"type": np.object_, "optional": False}, + PETAB_C.OBSERVABLE_NAME: {"type": np.object_, "optional": True}, + PETAB_C.OBSERVABLE_FORMULA: {"type": np.object_, "optional": False}, + PETAB_C.OBSERVABLE_TRANSFORMATION: { + "type": np.object_, + "optional": True, + }, + PETAB_C.NOISE_FORMULA: {"type": np.object_, "optional": False}, + PETAB_C.NOISE_DISTRIBUTION: {"type": np.object_, "optional": True}, }, "parameter": { - C.PARAMETER_ID: {"type": np.object_, "optional": False}, - C.PARAMETER_NAME: {"type": np.object_, "optional": True}, - C.PARAMETER_SCALE: {"type": np.object_, "optional": False}, - C.LOWER_BOUND: {"type": np.float64, "optional": False}, - C.UPPER_BOUND: {"type": np.float64, "optional": False}, - C.NOMINAL_VALUE: {"type": np.float64, "optional": False}, - C.ESTIMATE: {"type": np.object_, "optional": False}, - C.INITIALIZATION_PRIOR_TYPE: {"type": np.object_, "optional": True}, - C.INITIALIZATION_PRIOR_PARAMETERS: { + PETAB_C.PARAMETER_ID: {"type": np.object_, "optional": False}, + PETAB_C.PARAMETER_NAME: {"type": np.object_, "optional": True}, + PETAB_C.PARAMETER_SCALE: {"type": np.object_, "optional": False}, + PETAB_C.LOWER_BOUND: {"type": np.float64, "optional": False}, + PETAB_C.UPPER_BOUND: {"type": np.float64, "optional": False}, + PETAB_C.NOMINAL_VALUE: {"type": np.float64, "optional": False}, + PETAB_C.ESTIMATE: {"type": np.object_, "optional": False}, + PETAB_C.INITIALIZATION_PRIOR_TYPE: { + "type": np.object_, + "optional": True, + }, + PETAB_C.INITIALIZATION_PRIOR_PARAMETERS: { + "type": np.object_, + "optional": True, + }, + PETAB_C.OBJECTIVE_PRIOR_TYPE: {"type": np.object_, "optional": True}, + PETAB_C.OBJECTIVE_PRIOR_PARAMETERS: { "type": np.object_, "optional": True, }, - C.OBJECTIVE_PRIOR_TYPE: {"type": np.object_, "optional": True}, - C.OBJECTIVE_PRIOR_PARAMETERS: {"type": np.object_, "optional": True}, }, "condition": { - C.CONDITION_ID: {"type": np.object_, "optional": False}, - C.CONDITION_NAME: {"type": np.object_, "optional": False}, + PETAB_C.CONDITION_ID: {"type": np.object_, "optional": False}, + PETAB_C.CONDITION_NAME: {"type": np.object_, "optional": False}, }, "visualization": { - C.PLOT_ID: {"type": np.object_, "optional": False}, - C.PLOT_NAME: {"type": np.object_, "optional": True}, - C.PLOT_TYPE_SIMULATION: { + PETAB_C.PLOT_ID: {"type": np.object_, "optional": False}, + PETAB_C.PLOT_NAME: {"type": np.object_, "optional": True}, + PETAB_C.PLOT_TYPE_SIMULATION: { "type": np.object_, "optional": True, }, - C.PLOT_TYPE_DATA: {"type": np.object_, "optional": True}, - C.DATASET_ID: {"type": np.object_, "optional": True}, - C.X_VALUES: {"type": np.object_, "optional": True}, - C.X_OFFSET: {"type": np.float64, "optional": True}, - C.X_LABEL: {"type": np.object_, "optional": True}, - C.X_SCALE: {"type": np.object_, "optional": True}, - C.Y_VALUES: {"type": np.object_, "optional": True}, - C.Y_OFFSET: {"type": np.float64, "optional": True}, - C.Y_LABEL: {"type": np.object_, "optional": True}, - C.Y_SCALE: {"type": np.object_, "optional": True}, - C.LEGEND_ENTRY: {"type": np.object_, "optional": True}, + PETAB_C.PLOT_TYPE_DATA: {"type": np.object_, "optional": True}, + PETAB_C.DATASET_ID: {"type": np.object_, "optional": True}, + PETAB_C.X_VALUES: {"type": np.object_, "optional": True}, + PETAB_C.X_OFFSET: {"type": np.float64, "optional": True}, + PETAB_C.X_LABEL: {"type": np.object_, "optional": True}, + PETAB_C.X_SCALE: {"type": np.object_, "optional": True}, + PETAB_C.Y_VALUES: {"type": np.object_, "optional": True}, + PETAB_C.Y_OFFSET: {"type": np.float64, "optional": True}, + PETAB_C.Y_LABEL: {"type": np.object_, "optional": True}, + PETAB_C.Y_SCALE: {"type": np.object_, "optional": True}, + PETAB_C.LEGEND_ENTRY: {"type": np.object_, "optional": True}, }, } @@ -133,36 +148,48 @@ # Default Configurations of Default Values ALLOWED_STRATEGIES_OBS = { - C.OBSERVABLE_ID: STRATEGIES_DEFAULT, - C.OBSERVABLE_NAME: STRATEGIES_DEFAULT, - C.OBSERVABLE_FORMULA: STRATEGIES_DEFAULT, - C.OBSERVABLE_TRANSFORMATION: [USE_DEFAULT, NO_DEFAULT, MODE], - C.NOISE_FORMULA: [COPY_FROM, USE_DEFAULT, NO_DEFAULT, MODE], - C.NOISE_DISTRIBUTION: [USE_DEFAULT, NO_DEFAULT, MODE], + PETAB_C.OBSERVABLE_ID: STRATEGIES_DEFAULT, + PETAB_C.OBSERVABLE_NAME: STRATEGIES_DEFAULT, + PETAB_C.OBSERVABLE_FORMULA: STRATEGIES_DEFAULT, + PETAB_C.OBSERVABLE_TRANSFORMATION: [USE_DEFAULT, NO_DEFAULT, MODE], + PETAB_C.NOISE_FORMULA: [COPY_FROM, USE_DEFAULT, NO_DEFAULT, MODE], + PETAB_C.NOISE_DISTRIBUTION: [USE_DEFAULT, NO_DEFAULT, MODE], } ALLOWED_STRATEGIES_PAR = { - C.PARAMETER_ID: STRATEGIES_DEFAULT, - C.PARAMETER_NAME: STRATEGIES_DEFAULT, - C.PARAMETER_SCALE: [USE_DEFAULT, NO_DEFAULT, MODE], - C.LOWER_BOUND: [MIN_COLUMN, MAX_COLUMN, USE_DEFAULT, NO_DEFAULT, MODE], - C.UPPER_BOUND: [MAX_COLUMN, MAX_COLUMN, USE_DEFAULT, NO_DEFAULT, MODE], - C.NOMINAL_VALUE: [USE_DEFAULT, NO_DEFAULT, SBML_LOOK], - C.ESTIMATE: [USE_DEFAULT, NO_DEFAULT, MODE], + PETAB_C.PARAMETER_ID: STRATEGIES_DEFAULT, + PETAB_C.PARAMETER_NAME: STRATEGIES_DEFAULT, + PETAB_C.PARAMETER_SCALE: [USE_DEFAULT, NO_DEFAULT, MODE], + PETAB_C.LOWER_BOUND: [ + MIN_COLUMN, + MAX_COLUMN, + USE_DEFAULT, + NO_DEFAULT, + MODE, + ], + PETAB_C.UPPER_BOUND: [ + MAX_COLUMN, + MAX_COLUMN, + USE_DEFAULT, + NO_DEFAULT, + MODE, + ], + PETAB_C.NOMINAL_VALUE: [USE_DEFAULT, NO_DEFAULT, SBML_LOOK], + PETAB_C.ESTIMATE: [USE_DEFAULT, NO_DEFAULT, MODE], } ALLOWED_STRATEGIES_COND = { - C.CONDITION_ID: STRATEGIES_DEFAULT, - C.CONDITION_NAME: STRATEGIES_DEFAULT, + PETAB_C.CONDITION_ID: STRATEGIES_DEFAULT, + PETAB_C.CONDITION_NAME: STRATEGIES_DEFAULT, } ALLOWED_STRATEGIES_MEAS = { - C.OBSERVABLE_ID: STRATEGIES_DEFAULT, - C.PREEQUILIBRATION_CONDITION_ID: STRATEGIES_DEFAULT_EXT, - C.SIMULATION_CONDITION_ID: STRATEGIES_DEFAULT_EXT, - C.TIME: [NO_DEFAULT, USE_DEFAULT, MODE], - C.MEASUREMENT: [NO_DEFAULT, USE_DEFAULT, MODE], - C.OBSERVABLE_PARAMETERS: STRATEGIES_DEFAULT_EXT, - C.NOISE_PARAMETERS: STRATEGIES_DEFAULT_EXT, - C.DATASET_ID: [COPY_FROM, USE_DEFAULT, NO_DEFAULT, MODE], - C.REPLICATE_ID: [COPY_FROM, USE_DEFAULT, NO_DEFAULT, MODE], + PETAB_C.OBSERVABLE_ID: STRATEGIES_DEFAULT, + PETAB_C.PREEQUILIBRATION_CONDITION_ID: STRATEGIES_DEFAULT_EXT, + PETAB_C.SIMULATION_CONDITION_ID: STRATEGIES_DEFAULT_EXT, + PETAB_C.TIME: [NO_DEFAULT, USE_DEFAULT, MODE], + PETAB_C.MEASUREMENT: [NO_DEFAULT, USE_DEFAULT, MODE], + PETAB_C.OBSERVABLE_PARAMETERS: STRATEGIES_DEFAULT_EXT, + PETAB_C.NOISE_PARAMETERS: STRATEGIES_DEFAULT_EXT, + PETAB_C.DATASET_ID: [COPY_FROM, USE_DEFAULT, NO_DEFAULT, MODE], + PETAB_C.REPLICATE_ID: [COPY_FROM, USE_DEFAULT, NO_DEFAULT, MODE], } ALLOWED_STRATEGIES = { "observable": ALLOWED_STRATEGIES_OBS, @@ -171,34 +198,49 @@ "measurement": ALLOWED_STRATEGIES_MEAS, } DEFAULT_OBS_CONFIG = { - C.OBSERVABLE_ID: { + PETAB_C.OBSERVABLE_ID: { "strategy": COPY_FROM, - SOURCE_COLUMN: C.OBSERVABLE_FORMULA, + SOURCE_COLUMN: PETAB_C.OBSERVABLE_FORMULA, DEFAULT_VALUE: "new_observable", }, - C.OBSERVABLE_NAME: {"strategy": COPY_FROM, SOURCE_COLUMN: C.OBSERVABLE_ID}, - C.NOISE_FORMULA: {"strategy": USE_DEFAULT, DEFAULT_VALUE: 1}, - C.OBSERVABLE_TRANSFORMATION: { + PETAB_C.OBSERVABLE_NAME: { + "strategy": COPY_FROM, + SOURCE_COLUMN: PETAB_C.OBSERVABLE_ID, + }, + PETAB_C.NOISE_FORMULA: {"strategy": USE_DEFAULT, DEFAULT_VALUE: 1}, + PETAB_C.OBSERVABLE_TRANSFORMATION: { "strategy": USE_DEFAULT, - DEFAULT_VALUE: C.LIN, + DEFAULT_VALUE: PETAB_C.LIN, + }, + PETAB_C.NOISE_DISTRIBUTION: { + "strategy": USE_DEFAULT, + DEFAULT_VALUE: PETAB_C.NORMAL, }, - C.NOISE_DISTRIBUTION: {"strategy": USE_DEFAULT, DEFAULT_VALUE: C.NORMAL}, } DEFAULT_PAR_CONFIG = { - C.PARAMETER_NAME: { + PETAB_C.PARAMETER_NAME: { "strategy": COPY_FROM, - SOURCE_COLUMN: C.PARAMETER_ID, + SOURCE_COLUMN: PETAB_C.PARAMETER_ID, DEFAULT_VALUE: "new_parameter", }, - C.PARAMETER_SCALE: {"strategy": USE_DEFAULT, DEFAULT_VALUE: C.LOG10}, - C.LOWER_BOUND: {"strategy": MIN_COLUMN}, - C.UPPER_BOUND: {"strategy": MAX_COLUMN}, - C.ESTIMATE: {"strategy": USE_DEFAULT, DEFAULT_VALUE: 1}, - C.NOMINAL_VALUE: {"strategy": SBML_LOOK}, + PETAB_C.PARAMETER_SCALE: { + "strategy": USE_DEFAULT, + DEFAULT_VALUE: PETAB_C.LOG10, + }, + PETAB_C.LOWER_BOUND: {"strategy": MIN_COLUMN}, + PETAB_C.UPPER_BOUND: {"strategy": MAX_COLUMN}, + PETAB_C.ESTIMATE: {"strategy": USE_DEFAULT, DEFAULT_VALUE: 1}, + PETAB_C.NOMINAL_VALUE: {"strategy": SBML_LOOK}, } DEFAULT_COND_CONFIG = { - C.CONDITION_ID: {"strategy": USE_DEFAULT, DEFAULT_VALUE: "new_condition"}, - C.CONDITION_NAME: {"strategy": COPY_FROM, SOURCE_COLUMN: C.CONDITION_ID}, + PETAB_C.CONDITION_ID: { + "strategy": USE_DEFAULT, + DEFAULT_VALUE: "new_condition", + }, + PETAB_C.CONDITION_NAME: { + "strategy": COPY_FROM, + SOURCE_COLUMN: PETAB_C.CONDITION_ID, + }, } DEFAULT_MEAS_CONFIG = {} DEFAULT_CONFIGS = {